Tutorial · Sistem game

Cara buat sistem inventori dalam Roblox Studio

Inventori nampak seperti kerja antara muka, tetapi sama ada ia boleh digodam dan sama ada ia kehilangan item ditentukan oleh tempat item disimpan. Dalam panduan ini, item setiap pemain disimpan dalam jadual pada pelayan, setiap pemain menerima salinan dan melukisnya sebagai grid, equip Tool dan guna item habis pakai melalui permintaan yang disemak oleh pelayan, dan semuanya disimpan dalam data store.

Dikemas kini 20 November 202614 minit bacaanDitulis oleh

Ringkasnya

Simpan item setiap pemain dalam jadual pada pelayan, di dalam ModuleScript dalam ServerScriptService, dan hanya kod ini boleh menambah, membuang dan menyusun item menjadi stack. Huraikan item sekali sahaja dalam ModuleScript dalam ReplicatedStorage (id, nama, stack maksimum). Selepas setiap perubahan, pelayan menghantar RemoteEvent kepada pemain itu dengan salinan inventorinya, dan LocalScript melukisnya sebagai grid dengan ScrollingFrame dan UIGridLayout.

  • Client tidak pernah menambah item. Ia hanya boleh meminta, contohnya "equip pedang saya", dan pelayan menyemak bahawa pemain memang memilikinya sebelum melakukan apa-apa.
  • Item hanya muncul melalui kod pelayan yang anda kawal: ambil item, pembelian di kedai selepas semakan pada pelayan, ganjaran.
  • Simpan id item dan jumlahnya, bukan Tool, dengan DataStoreService apabila pemain keluar, apabila pelayan ditutup dan setiap beberapa minit. Jangan sekali-kali simpan pemain yang datanya gagal dimuatkan.
Di halaman ini
  1. Cara ia berfungsi
  2. Kenapa item pada pelayan
  3. 1. Sediakan Explorer
  4. 2. Katalog item
  5. 3. Inventori pada pelayan
  6. 4. Muat dan simpan
  7. 5. Ambil item
  8. 6. Equip dan guna
  9. 7. Grid UI
  10. Ujian
  11. Common errors
  12. Dengan RoCode
  13. Soalan lazim
  14. Sumber dan bacaan lanjut

Cara inventori berfungsi

IlustrasiTekan B, halakan kursor ke atas item untuk membaca penerangannya, klik Sword untuk memegangnya.

Sistem ini terdiri daripada enam bahagian kecil, setiap satu dengan satu tugas. Semua peraturan tentang item tinggal dalam satu modul pelayan, jadi apabila sesuatu rosak, anda hanya perlu mencari di satu tempat.

Bahagian sistem dan di mana ia berjalan
BahagianJenis dan tempatTugas
ItemCatalogModuleScript dalam ReplicatedStorageApa itu setiap item: nama, penerangan, stack maksimum dan sama ada ia boleh di-equip atau digunakan. Ia dibaca oleh pelayan dan semua client.
InventoryServiceModuleScript dalam ServerScriptServiceMenyimpan slot semua pemain. Satu-satunya kod yang menambah, membuang dan menyusun item menjadi stack.
InventoryDataScript dalam ServerScriptServiceMemuatkan item pemain apabila dia masuk dan menyimpannya.
InventoryActionsScript dalam ServerScriptServiceMenyemak dan melaksanakan permintaan equip dan guna.
ItemPickupScript di dalam PartMemberi item kepada sesiapa yang mengambilnya.
InventoryClientLocalScript dalam StarterPlayerScriptsMelukis grid dan menghantar permintaan. Ia sendiri tidak mengubah apa-apa.

Data bergerak satu hala. Pelayan mengubah inventori, kemudian menghantar InventoryUpdated kepada pemain itu dengan seluruh inventori, dan client melukisnya semula. Apabila pemain klik slot, client menghantar EquipItem atau UseItem dengan id item; pelayan menyemak permintaan, membuat perubahan, dan salinan baharu tiba melalui laluan yang sama. Menghantar seluruh inventori lebih mudah daripada menghantar perubahan, dan untuk beberapa dozen slot mesejnya tetap kecil.

Kenapa client tidak pernah menambah item

Memang menggoda untuk menambah item terus dalam LocalScript yang memaparkannya: pemain klik, slot terisi. Ini gagal dalam dua cara.

  • Tiada orang lain yang nampak. Perubahan dalam LocalScript hanya wujud pada peranti pemain itu. Pelayan tidak tahu tentangnya, jadi ia tidak disimpan, dan tiada skrip pelayan boleh menggunakannya.
  • Sesiapa sahaja boleh memalsukannya. Jika anda membaikinya dengan remote seperti AddItem(itemId, amount), penipu boleh memanggil event itu sendiri, dengan apa-apa argumen dan seberapa kerap yang dia mahu. Panduan keselamatan Roblox menyatakan bahawa pelayan mesti menyemak semua yang dihantar oleh client sebelum menggunakannya.

Sebab itu dalam panduan ini client hanya boleh meminta sesuatu dilakukan dengan item yang pemain sudah miliki: "equip ini" dan "guna ini". Setiap permintaan membawa satu id item dan tiada jumlah, dan pada pelayan ia melalui satu semakan: ia rentetan, item itu wujud, pemain ada sekurang-kurangnya satu, dan pemain menghantar tidak lebih daripada empat permintaan sesaat. Kemudian pelayan sendiri mencari Tool melalui katalog. Ia tidak pernah menerima Tool, laluan atau instance daripada client, seperti yang diingatkan oleh panduan yang sama.

Item masuk ke inventori hanya melalui kod pelayan: ambil item yang disemak oleh pelayan, pembelian yang wangnya sudah ditolak oleh pelayan (dibina dalam panduan kedai), ganjaran quest atau drop. Tentang remote secara umum, termasuk semakan jenis argumen lain, baca panduan RemoteEvent.

Langkah 1: sediakan Explorer

Cipta objek ini secara manual. Skrip dalam langkah seterusnya mencarinya mengikut nama, jadi tulis setiap nama tepat seperti di sini.

  1. Dalam ReplicatedStorage, masukkan Folder bernama InventoryRemotes. Di dalamnya, masukkan tiga RemoteEvent bernama InventoryUpdated, EquipItem dan UseItem.
  2. Dalam ServerStorage, masukkan Folder bernama ItemTools. Di dalamnya, masukkan Tool bernama Sword, dan di dalam Tool itu Part bernama Handle (1 kali 4 kali 1 stud sudah memadai). Pastikan Anchored pada Handle tidak ditanda: Roblox mengingatkan bahawa watak akan tersekat di tempatnya jika memegang tool dengan part yang di-anchor. Tool yang anda sudah ada juga boleh digunakan jika namanya sama dengan katalog dalam langkah 2.
  3. Tambah skrip semasa anda melalui langkah-langkahnya. Pokok ini menunjukkan ke mana setiap satunya pergi.
Explorer selepas panduan ini selesai
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: huraikan item dalam katalog

Katalog menghuraikan setiap item yang boleh wujud, sekali sahaja. Inventori kemudian hanya menyimpan id item dan jumlahnya. Dengan cara ini data simpanan kekal kecil, dan kemudian anda boleh menukar nama item atau menulis semula penerangannya tanpa menyentuh data simpanan sesiapa.

Masukkan ModuleScript ke dalam ReplicatedStorage, namakannya ItemCatalog dan gantikan kandungannya dengan ini:

ModuleScript dalam ReplicatedStorage bernama ItemCatalog
-- Semua item yang boleh wujud dalam game. Senarai ini dibaca oleh pelayan dan semua
-- client; hanya pelayan yang menentukan siapa memiliki apa.
export type Item = {
	id: string, -- mesti sama dengan kunci di bawah
	name: string,
	description: string,
	maxStack: number, -- berapa banyak item ini muat dalam satu slot
	icon: string?, -- gambar pilihan: "rbxassetid://" ditambah ID imej anda
	toolName: string?, -- Tool dalam ServerStorage.ItemTools: item boleh di-equip
	heal: number?, -- berapa banyak nyawa dipulihkan: item boleh digunakan habis
}

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

-- Memulangkan item dengan id ini, atau nil jika item itu tiada
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Medan pilihan menentukan apa yang item itu buat. toolName menjadikannya boleh di-equip, heal menjadikannya boleh digunakan, dan item tanpa kedua-dua medan, seperti kayu, kekal dalam inventori sehingga kod pelayan lain membuangnya (crafting, jualan).

Untuk menambah item, tambah entri yang kunci dan idnya sama. Id peka huruf besar kecil dan id itulah yang disimpan, jadi jangan sekali-kali tukar id apabila pemain sudah memiliki item itu: tukar namenya.

Langkah 3: simpan inventori pada pelayan

ModuleScript ini memiliki inventori setiap pemain. Setiap inventori ialah senarai slot, setiap slot mengandungi id item dan jumlah, ditambah kapasiti 20 slot. Skrip pelayan lain memanggil fungsinya, dan tiada orang lain yang menyunting jadual itu.

Masukkan ModuleScript ke dalam ServerScriptService dan namakannya InventoryService:

ModuleScript dalam ServerScriptService bernama InventoryService
-- Satu-satunya kod yang mengubah inventori. Ia terletak dalam ServerScriptService,
-- tempat client tidak boleh melihat atau menjalankannya.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Mod strict tidak nampak apa yang dipulangkan oleh require melalui WaitForChild, jadi
-- kita huraikan bahagian modul yang digunakan oleh skrip 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 bagi setiap pemain
local STARTER_ITEMS: { Slot } = { -- apa yang dimiliki pemain yang benar-benar baharu pada permulaan
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Menghantar salinan inventori kepada pemiliknya. Dipanggil selepas 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

-- Peraturan stack: isi dahulu stack yang belum penuh, kemudian mulakan stack baharu
-- dalam slot kosong. Memulangkan jumlah yang ditambah, mungkin kurang daripada 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 item ini muat: ruang dalam stacknya 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

-- Menambah sehingga amount unit item. Memulangkan jumlah yang ditambah (0 jika
-- item itu tiada, inventori penuh atau belum dimuatkan).
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

-- Membuang tepat amount unit item, bermula dari stack terakhir.
-- Jika pemain ada kurang daripada itu, tiada apa dibuang dan false dipulangkan.
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
	-- Bergerak dari hujung supaya table.remove tidak melangkau 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 apabila data simpanan pemain sudah dimuatkan. saved ialah apa yang
-- dipulangkan oleh data store: nil untuk pemain baharu. Setiap entri melalui semula
-- peraturan stack, jadi item yang dipadam dan saiz stack lama tidak merosakkan apa-apa.
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 ringkas untuk disimpan, atau nil jika data pemain tidak pernah dimuatkan
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 :: selepas require hanya diperlukan oleh penyemak jenis Luau, yang tidak nampak apa yang dipulangkan oleh modul yang dicari melalui WaitForChild. Semasa game berjalan, ia tidak mengubah apa-apa. Skrip lain dalam panduan ini melakukan perkara yang sama.

Cara peraturan stack berfungsi dengan katalog di atas, di mana epal boleh di-stack sehingga 10:

  • Jika anda menambah 15 epal kepada pemain yang ada stack 7, stack itu diisi sehingga 10, kemudian stack baharu 5 dimulakan.
  • Apabila slot habis, add menambah apa yang muat dan memulangkan nombor itu. Panggil spaceFor dahulu apabila anda perlukan semua atau tiada langsung, seperti yang dilakukan oleh ambil item dalam langkah 5.
  • remove berfungsi secara semua atau tiada langsung. Meminta 3 epal daripada pemain yang ada 2 tidak membuang apa-apa dan memulangkan false, jadi semak hasilnya sebelum memberi apa-apa sebagai balasan.
  • Tiada lubang dalam slot: apabila slot menjadi kosong, yang lain beranjak ke atas. Ini memudahkan senarai dihantar dan disimpan. Tentang slot yang mengekalkan kedudukannya, lihat soalan di hujung.
Apa yang boleh dipanggil oleh skrip pelayan lain
FungsiMemulangkanUntuk apa
add(player, itemId, amount)Jumlah yang ditambahAmbil item, ganjaran, pembelian
remove(player, itemId, amount)true jika semuanya dibuangGuna, jual, crafting
count(player, itemId)Jumlah merentas semua stackSemak apa yang pemain miliki
spaceFor(player, itemId)Berapa banyak lagi yang muatSemakan sebelum menambah secara semua atau tiada langsung
getEquipped, setEquippedId item yang di-equip atau nilEquip, dalam langkah 6
load, serialize, unloadSalinan sedia untuk disimpan (serialize)Muat dan simpan, dalam langkah 4

Langkah 4: muat dan simpan setiap inventori

Inventori tinggal dalam memori pelayan, jadi ia hilang apabila pemain keluar. Skrip ini memuatkan slot pemain daripada data store apabila dia masuk, dan menulisnya semula apabila dia keluar, apabila pelayan ditutup dan setiap tiga minit sekiranya pelayan crash. Ia hanya menyimpan id item dan jumlah: data store tidak boleh menyimpan Instance, contohnya Tool.

Masukkan Script ke dalam ServerScriptService dan namakannya InventoryData:

Script dalam 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 berjaya dimuatkan akan disimpan. Selepas muatan gagal
-- jangan simpan, jika tidak inventori kosong akan menggantikan inventori sebenar.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Satu permintaan yang gagal tidak patut menyebabkan sesiapa kehilangan item, jadi kita cuba beberapa kali.
-- GetDataStore juga di dalam pcall, jadi sesi Studio tanpa akses kepada data
-- store mendapat amaran dan bukannya menghentikan skrip 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 semasa kita memuatkan
	end
	if ok then
		InventoryService.load(player, saved) -- saved ialah nil untuk pemain baharu
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Biasanya bermaksud akses Studio kepada API services dimatikan. Main dengan
		-- item permulaan supaya boleh diuji, tetapi jangan sekali-kali simpan.
		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 -- data tidak pernah dimuatkan, tiada apa yang selamat 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)

-- Apabila pelayan ditutup, simpan semua yang masih ada dan tunggu setiap
-- simpanan yang sedang berjalan, termasuk yang dimulakan 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 orang setiap beberapa minit, supaya pelayan crash hanya merugikan beberapa minit, bukan seluruh sesi
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Apa yang skrip ini buat dan kenapa:

  • Muat dengan nilai lalai. Pemain baharu tiada nilai simpanan, jadi GetAsync memulangkan nil dan dia mendapat item permulaan. Slot yang disimpan melalui semula peraturan stack, jadi item yang dibuang daripada katalog atau stack maksimum yang dikecilkan tidak akan merosakkan muatan. Apa-apa yang tidak lagi muat atau id yang tiada lagi dalam katalog akan dibuang, dan simpanan seterusnya menjadikannya kekal, jadi kekalkan dalam katalog setiap id yang mungkin dimiliki pemain.
  • Jangan simpan selepas muatan gagal. Hanya pemain dalam canSave yang ditulis. Pada pelayan sebenar, pemain yang datanya gagal dimuatkan walaupun selepas tiga percubaan diminta masuk semula. Dalam Studio, dia sebaliknya mendapat item permulaan yang tidak disimpan, beberapa saat lewat kerana percubaan semula. Ini akan berlaku sehingga place diterbitkan dengan akses API dihidupkan.
  • Simpan semasa keluar dan semasa pelayan ditutup. BindToClose menyimpan semua yang masih ada pada pelayan dan menunggu simpanan yang sedang berjalan. Roblox memberi fungsi yang diikat sehingga 30 saat.
  • Kekal dalam had. Satu penulisan bagi setiap pemain setiap tiga minit ditambah satu semasa keluar jauh di bawah bajet standard pelayan, iaitu 60 penulisan seminit ditambah 40 bagi setiap pemain (mengikut dokumentasi pada 30 September 2026). Corak kunci User_ diambil daripada cadangan Roblox, dan menghantar user ID kepada SetAsync mengaitkan data dengan pemain itu, yang sangat disyorkan oleh Roblox untuk mengendalikan permintaan pemadaman data.

Untuk game kecil, ini asas yang kukuh. Penguncian sesi, yang menghalang pemain yang cepat bertukar pelayan daripada memuatkan data sebelum pelayan lama menyimpannya, dan bila perlu menggunakan UpdateAsync dan bukannya SetAsync, diterangkan dalam tutorial DataStore.

Langkah 5: beri item dari dunia

Ambil item ialah cara paling mudah untuk item masuk ke inventori: part dengan ProximityPrompt yang menambah item apabila pemain menggunakannya. Skrip mendengar event Triggerednya pada pelayan, jadi item ditambah di tempat yang client tidak boleh campur tangan.

  1. Tambah Part ke Workspace, namakannya Apple dan warnakan merah. Hidupkan Anchored dan matikan CanCollide, supaya tiada siapa terlanggarnya semasa ia tidak kelihatan. Prompt memaparkan nama part itu.
  2. Dengan part dipilih, tatal tetingkap Properties ke bahagian Attributes dan klik +. Tambah ItemId dengan jenis string dan klik Save, kemudian tetapkan nilai apple. Dengan cara yang sama, tambah Amount jenis number dengan nilai 1.
  3. Masukkan Script ke dalam part, namakannya ItemPickup dan tampal kod ini:
Script dalam part Apple dalam Workspace bernama ItemPickup
-- Letakkan Script ini di dalam Part dan beri Part dua atribut:
-- ItemId (rentetan, contohnya apple) dan Amount (nombor, contohnya 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 -- orang lain baru sahaja mengambilnya
	end
	-- Semak jarak pada pelayan, jangan percaya permintaan
	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 -- ruang tidak cukup: biarkan item 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 itu untuk meletakkan lebih banyak item. Tukar atributnya untuk memberi kayu, satu lagi pedang atau satu stack epal.

Roblox menyemak jarak untuk Triggered, tetapi panduan keselamatannya tetap menyuruh anda menyemak prompt pada pelayan: penipu boleh mencetuskan event prompt walaupun Enabled ialah false, dan boleh menarik part yang tidak di-anchor ke wataknya. Sebab itu skrip menyemak Enabled dan jarak sendiri, dan sebab itu part di-anchor.

Mana-mana skrip pelayan lain memberi item dengan cara yang sama. Selepas pembelian, quest atau kill, sambungkan InventoryService melalui require seperti skrip di atas dan panggil InventoryService.add(player, "wood", 5). Semak spaceFor dahulu apabila item itu tidak boleh hilang. Sumber lain boleh jadi NPC: dalam panduan dialog NPC, jawapan mencetuskan tindakan pada pelayan, dan tindakan itu juga boleh memanggil InventoryService.add.

Langkah 6: equip Tool dan guna item

Dua RemoteEvent membawa satu-satunya permintaan yang boleh dibuat oleh client. EquipItem meletakkan salinan Tool item daripada ServerStorage ke dalam Backpack pemain (hotbar di bahagian bawah skrin) dan ke tangannya, dan permintaan kedua menyimpannya semula. UseItem membuang satu unit item yang boleh digunakan dan menerapkan kesannya, di sini memulihkan nyawa.

Masukkan Script ke dalam ServerScriptService dan namakannya InventoryActions:

Script dalam 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 permintaan bermula di sini. Client boleh menghantar apa sahaja bila-bila masa, jadi
-- kita semak jenis, sama ada item wujud, sama ada pemain memilikinya, dan kekerapannya.
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

-- Memusnahkan Tool item ini di mana sahaja 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) -- satu tool yang di-equip pada satu masa

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

	-- Salinan kedua dalam StarterGear disalin semula ke Backpack selepas 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) -- terus ke tangan
	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) -- klik sekali lagi pada item yang di-equip akan menyimpannya semula
	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 -- mati atau nyawa sudah penuh: jangan bazirkan item
	end
	-- Ambil item dahulu, dan pulihkan nyawa hanya jika ia berjaya
	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 dibenarkan bagi setiap permintaan
PermintaanClient menghantarPelayan menyemak sebelum bertindak
EquipItemId itemIa rentetan, item itu wujud, pemain memilikinya, permintaan tiba tidak lebih daripada empat sesaat, item itu ada toolName, dan Tool dengan nama itu ada dalam ServerStorage.ItemTools
UseItemId itemSemakan jenis, pemilikan dan kekerapan yang sama, item itu ada nilai heal, watak hidup dan cedera, dan satu item dibuang sebelum nyawa ditambah

Tiga butiran menghalang Tool daripada menjadi dua atau hilang. Salinan itu mempunyai CanBeDropped bernilai false, kerana Tool yang dijatuhkan jatuh ke Workspace, di mana pemain lain boleh mengambilnya, sedangkan yang asal masih kekal dalam inventori. Setiap salinan membawa atribut InventoryItem, jadi semasa menyimpan semula anda boleh mencari dan memusnahkan setiap salinan di mana sahaja ia berada. Dan jika pemain ada bekas StarterGear, salinan kedua dimasukkan ke dalamnya. Roblox menyalin StarterGear ke Backpack setiap kali watak muncul, jadi pedang yang di-equip kembali selepas respawn.

Hanya satu Tool di-equip pada satu masa, dan equip tidak disimpan, jadi selepas masuk semula pemain bermula dengan hotbar kosong. Jika kemudian anda menambah jualan atau menjatuhkan item, simpan semula item itu sebelum salinan terakhirnya meninggalkan inventori.

Pedang sementara ini boleh ditukar menjadi pedang yang benar-benar bertarung: bina Tool mengikut panduan pedang, kekalkan namanya Sword dan letakkan dalam ItemTools menggantikan yang sementara. Skrip pelayan daripada panduan itu akan menyemak setiap pukulan, tidak kira bagaimana pemain mendapat pedang itu.

Langkah 7: lukis grid inventori

LocalScript membina seluruh tetingkap dalam kod, jadi tiada apa yang perlu disusun secara manual. ScrollingFrame memegang slot, UIGridLayout di dalamnya menyusun slot dalam baris, dan AutomaticCanvasSize membesarkan kawasan tatal apabila baris ditambah.

Dalam Explorer, buka StarterPlayer, masukkan LocalScript ke dalam StarterPlayerScripts dan namakannya InventoryClient:

LocalScript dalam 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. Bina tetingkap sekali sahaja. ResetOnSpawn = false mengekalkannya selepas 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 membesarkannya mengikut sel
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 bagi setiap slot. Ini hanya melukis apa yang dihantar oleh pelayan;
-- inventori itu sendiri tidak pernah diubah dari sini.
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, bukan arah: pelayan menyemak permintaan dan menghantar 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

-- Pelayan menghantar ini selepas muatan dan selepas setiap perubahan
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Buka dan tutup dengan butang atau kekunci 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 dalam StarterPlayerScripts berjalan sekali bagi setiap sesi, dan ResetOnSpawn = false mengekalkan ScreenGui apabila watak respawn, jadi grid terus menunjukkan salinan terakhir yang dihantar oleh pelayan.

Client melukis satu sel bagi setiap slot, termasuk yang kosong, jadi inventori 20 slot sentiasa kelihatan seperti 20 slot. Setiap kemas kini memusnahkan sel lama dan membina yang baharu, ini mudah dan sesuai untuk beberapa dozen slot. Jika pelayan menghantar InventoryUpdated sebelum skrip ini menyambung kepadanya, Roblox meletakkan mesej itu dalam baris gilir dan menghantarnya sebaik sahaja pengendali disambungkan, jadi inventori pertama tidak hilang.

Mahu melukis tetingkap dalam Studio? Bina ScreenGui dengan satu slot templat dan Clone slot itu dalam makeCell. Untuk ikon, beri item dalam katalog icon dengan imej yang anda muat naik, dan selnya akan menunjukkan gambar dan bukannya nama.

Uji inventori

  1. Tekan Play. Buka inventori dengan butang di sebelah kiri atau kekunci B: pemain baharu ada Sword dan 3 Apple, dan pembilang menunjukkan 2 / 20 slots. Selagi Studio tidak boleh mengakses data store, item muncul selepas beberapa saat, selepas amaran muatan dalam Output, dan tidak disimpan.
  2. Klik Sword. Pedang muncul di tangan anda dan dalam hotbar, dan slotnya mendapat bingkai ungu. Klik sekali lagi untuk menyimpannya.
  3. Pergi ke part Apple dan gunakan prompt-nya. Stack epal bertambah kepada 4, dan part itu hilang selama 15 saat.
  4. Untuk menguji pemulihan nyawa, kurangkan nyawa dahulu. Tukar Client/Server kepada Server, pilih Humanoid watak anda dalam Explorer, tetapkan Health kepada 50, tukar semula kepada Client dan klik Apple.
  5. Dengan akses Studio kepada API services dihidupkan, hentikan game dan mulakan semula. Epal yang diambil masih ada. Jika muatan atau simpanan gagal, Output akan memberitahunya.

Untuk menguji dengan beberapa pemain, pilih Server & Clients dengan 2 client dalam tetapan ujian. Setiap pemain hanya nampak inventorinya sendiri, dan pedang di tangan pemain lain dilihat oleh kedua-duanya.

Ralat biasa dan cara membaikinya

Kebanyakan masalah kelihatan dalam tetingkap Output sebagai amaran atau baris ralat merah. Baca yang pertama: ralat seterusnya selalunya berpunca daripadanya.

Infinite yield possible pada panggilan WaitForChild

Skrip sedang menunggu objek yang tidak wujud dengan nama yang tepat itu. Bandingkan Explorer anda dengan pokok dalam langkah 1: InventoryRemotes dengan tiga RemoteEvent dalam ReplicatedStorage, ItemTools dalam ServerStorage dan dua modul. Nama peka huruf besar kecil. Panduan ralat skrip menerangkan amaran ini dengan lebih terperinci.

Grid terbuka tetapi kekal kosong

Client hanya melukis apa yang dihantar oleh pelayan. Cari amaran Inventory load failed dalam Output dan pastikan InventoryData ialah Script, bukan LocalScript, dalam ServerScriptService, dengan ModuleScript InventoryService di sebelahnya. Jika Output menunjukkan ralat Remote event invocation, tiada siapa pada client yang mendengar InventoryUpdated: cari ralat yang lebih awal daripada InventoryClient.

Item ditetapkan semula setiap kali saya bermain dalam Studio

Jika Output menulis Inventory not loaded: playing with starter items that will not be saved, place belum diterbitkan atau akses Studio kepada API services dimatikan. Hidupkannya seperti dalam langkah 4, dalam salinan ujian game anda.

Klik pada pedang tidak melakukan apa-apa

Cari Cannot equip sword dalam Output: Tool dalam ServerStorage.ItemTools mesti dinamakan tepat seperti toolName dalam katalog. Tool juga perlukan part bernama Handle supaya ia boleh dipegang, melainkan anda menetapkan RequiresHandlenya kepada false.

Prompt ambil item muncul tetapi tiada apa yang ditambah

Atribut ItemId mesti sama tepat dengan id dalam katalog, termasuk huruf besar kecil: apple, bukan Apple. Tiada apa ditambah selagi inventori pemain masih dimuatkan atau apabila tiada ruang untuk keseluruhan jumlah.

Simpanan rosak selepas saya mengubah apa yang disimpan

Data store menerima data ringkas: rentetan, nombor, nilai boolean dan jadual yang terdiri daripadanya. Menyimpan Tool, Part atau mana-mana Instance lain akan gagal, atau nilai disimpan sebagai nil. Simpan id item dan jumlah, dan bina semula yang lain daripada katalog, seperti yang dilakukan oleh serialize.

Buat dengan RoCode

Jika lebih mudah bagi anda menerangkan sistem ini daripada membinanya secara manual, RoCode boleh membinanya dalam place yang anda buka. Ia ialah ejen AI untuk Roblox Studio: anda terangkan ciri dalam chat web, dan plugin Studionya mencipta skrip dan objek dalam Explorer anda, bukannya memberi kod untuk ditampal.

Anda tulis

Tambah inventori 20 slot dengan stack item, grid UI yang dibuka dengan B, pedang daripada ServerStorage yang boleh di-equip oleh pemain, epal yang memulihkan nyawa, dan simpanan melalui DataStoreService.

RoCode buat
  • Boleh melihat place anda apabila sesuatu langkah memerlukannya, melalui Search Game dan Search Scripts, supaya ia membina di atas item, remote atau kod simpanan yang sudah ada dan bukannya menambah sistem kedua
  • Mencipta folder dan RemoteEvent melalui Create Instance, dan ModuleScript, Script dan LocalScript melalui Create Script
  • Boleh membina rangka tetingkap melalui Build UI, yang ada susun atur inventori dengan slot sementara; kod yang mengisi slot daripada pelayan ditulis sebagai skrip berasingan
  • Menyemak kompilasi setiap skrip dalam Studio melalui Check Script, yang menangkap ralat kompilasi dan beberapa corak berisiko, tetapi tidak menyemak jenis, tidak melakukan lint dan tidak menjalankan kod anda

Setiap kumpulan perubahan ialah satu titik undo dalam Studio. RoCode tidak boleh menghidupkan akses Studio kepada API services, itu anda lakukan sendiri. Dengan plugin 3.9 atau lebih baharu, ia boleh menjalankan playtest pendek dan membaca ralat, dan dengan plugin 3.9.15 atau lebih baharu, watak ujiannya boleh menekan kekunci dan equip item, tetapi ia hanya menyemak apa yang ia sendiri putuskan untuk diuji, jadi semak simpanan dengan playtest sendiri. Inventori berdiri di atas sistem lain seperti simpanan dan tool, dan pembina game AI yang membina dalam place Studio anda sendiri menambahnya satu prompt pada satu masa. Cara RoCode bersambung ke Studio.

Soalan lazim

Patutkah saya guna Backpack Roblox dan bukannya inventori sendiri?

Backpack ialah inventori terbina dalam Roblox: setiap Tool di dalamnya dipaparkan sebagai butang dalam hotbar. Jika semua item dalam game anda ialah Tool dan anda tidak perlukan stack, jumlah dan had slot, ia mungkin sudah cukup, walaupun anda tetap perlu menyimpan Tool yang dimiliki setiap pemain. Inventori sendiri diperlukan untuk item yang bukan Tool, contohnya bahan dan item habis pakai. Panduan ini menggunakan kedua-duanya: inventori menyimpan semuanya, dan Backpack memegang Tool yang di-equip.

Bagaimana untuk menyembunyikan hotbar standard dalam Roblox?

Daripada LocalScript, panggil StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Apabila hotbar disembunyikan, pemain perlukan cara lain untuk memegang dan menyimpan Tool yang di-equip, contohnya butang yang meminta pelayan memanggil Humanoid:EquipTool atau Humanoid:UnequipTools.

Bagaimana untuk membuat slot mengekalkan kedudukan untuk drag and drop?

Simpan senarai dengan panjang tetap, satu entri bagi setiap slot, dan tandakan slot kosong dengan nilai seperti id kosong, bukan nil, kerana Roblox tidak menasihatkan penghantaran jadual dengan nil melalui RemoteEvent. Kemudian tambah RemoteEvent MoveItem yang menghantar dua nombor slot, dan biar pelayan menyemak bahawa kedua-duanya integer dari 1 hingga kapasiti sebelum menukar tempatnya.

Berapa besar inventori yang disimpan boleh jadi?

Satu nilai dalam data store boleh mencapai 4,194,304 aksara selepas disiri (mengikut dokumentasi pada 30 September 2026). Senarai id dan jumlah hanya menggunakan sebahagian kecil daripadanya. Yang membesarkan saiz simpanan ialah teks bagi setiap item, contohnya nama tersuai atau penerangan panjang yang disimpan untuk setiap item.

Bagaimana untuk membeli dan menjual item dengan syiling?

Lakukan semuanya pada pelayan. Untuk menjual, panggil InventoryService.remove dan bayar hanya jika ia memulangkan true. Untuk membeli, semak harga dan spaceFor, ambil syiling, kemudian panggil add. Panduan kedai membina bahagian pembelian.

Sumber dan bacaan lanjut

Cara kod disemak: setiap skrip di halaman ini lulus semakan jenis Luau yang ketat dengan definisi API Roblox (luau-lsp, 20 November 2026). Semakan jenis mengesan kesilapan nama API dan jenis yang salah, tetapi bukan kesilapan logik permainan, jadi uji semuanya dalam Studio sebelum anda menerbitkannya.

Cuba RoCode dalam permainan anda.

Kredit percuma setiap hari, tanpa kad. Pasang plugin, terangkan ciri yang anda mahu dan semak hasilnya dalam Studio.