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
Cara inventori berfungsi
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 | Jenis dan tempat | Tugas |
|---|---|---|
ItemCatalog | ModuleScript dalam ReplicatedStorage | Apa itu setiap item: nama, penerangan, stack maksimum dan sama ada ia boleh di-equip atau digunakan. Ia dibaca oleh pelayan dan semua client. |
InventoryService | ModuleScript dalam ServerScriptService | Menyimpan slot semua pemain. Satu-satunya kod yang menambah, membuang dan menyusun item menjadi stack. |
InventoryData | Script dalam ServerScriptService | Memuatkan item pemain apabila dia masuk dan menyimpannya. |
InventoryActions | Script dalam ServerScriptService | Menyemak dan melaksanakan permintaan equip dan guna. |
ItemPickup | Script di dalam Part | Memberi item kepada sesiapa yang mengambilnya. |
InventoryClient | LocalScript dalam StarterPlayerScripts | Melukis 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.
- Dalam ReplicatedStorage, masukkan Folder bernama
InventoryRemotes. Di dalamnya, masukkan tiga RemoteEvent bernamaInventoryUpdated,EquipItemdanUseItem. - Dalam ServerStorage, masukkan Folder bernama
ItemTools. Di dalamnya, masukkan Tool bernamaSword, dan di dalam Tool itu Part bernamaHandle(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. - Tambah skrip semasa anda melalui langkah-langkahnya. Pokok ini menunjukkan ke mana setiap satunya pergi.
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:
-- 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:
-- 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,
addmenambah apa yang muat dan memulangkan nombor itu. PanggilspaceFordahulu apabila anda perlukan semua atau tiada langsung, seperti yang dilakukan oleh ambil item dalam langkah 5. removeberfungsi secara semua atau tiada langsung. Meminta 3 epal daripada pemain yang ada 2 tidak membuang apa-apa dan memulangkanfalse, 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.
| Fungsi | Memulangkan | Untuk apa |
|---|---|---|
add(player, itemId, amount) | Jumlah yang ditambah | Ambil item, ganjaran, pembelian |
remove(player, itemId, amount) | true jika semuanya dibuang | Guna, jual, crafting |
count(player, itemId) | Jumlah merentas semua stack | Semak apa yang pemain miliki |
spaceFor(player, itemId) | Berapa banyak lagi yang muat | Semakan sebelum menambah secara semua atau tiada langsung |
getEquipped, setEquipped | Id item yang di-equip atau nil | Equip, dalam langkah 6 |
load, serialize, unload | Salinan 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:
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
GetAsyncmemulangkan 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
canSaveyang 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.
BindToClosemenyimpan 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 kepadaSetAsyncmengaitkan 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.
- Tambah Part ke Workspace, namakannya
Appledan warnakan merah. Hidupkan Anchored dan matikan CanCollide, supaya tiada siapa terlanggarnya semasa ia tidak kelihatan. Prompt memaparkan nama part itu. - Dengan part dipilih, tatal tetingkap Properties ke bahagian Attributes dan klik +. Tambah
ItemIddengan jenis string dan klik Save, kemudian tetapkan nilaiapple. Dengan cara yang sama, tambahAmountjenis number dengan nilai1. - Masukkan Script ke dalam part, namakannya
ItemPickupdan tampal kod ini:
-- 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:
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)
| Permintaan | Client menghantar | Pelayan menyemak sebelum bertindak |
|---|---|---|
EquipItem | Id item | Ia 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 |
UseItem | Id item | Semakan 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:
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
- 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.
- Klik Sword. Pedang muncul di tangan anda dan dalam hotbar, dan slotnya mendapat bingkai ungu. Klik sekali lagi untuk menyimpannya.
- Pergi ke part Apple dan gunakan prompt-nya. Stack epal bertambah kepada 4, dan part itu hilang selama 15 saat.
- Untuk menguji pemulihan nyawa, kurangkan nyawa dahulu. Tukar Client/Server kepada Server, pilih
Humanoidwatak anda dalam Explorer, tetapkan Health kepada 50, tukar semula kepada Client dan klik Apple. - 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.
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.
- 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
- Roblox Creator Docs: Remote events and callbacks (dalam bahasa Inggeris). FireClient, OnServerEvent, sekatan pada argumen dan cara mesej tanpa penerima diletakkan dalam baris gilir
- Roblox Creator Docs: Securing the client-server boundary (dalam bahasa Inggeris). semakan input remote, semakan ProximityPrompt dan pemalsuan data dalam data store
- Roblox Creator Docs: Data stores (dalam bahasa Inggeris). GetAsync, SetAsync dan menghidupkan akses daripada Studio
- Roblox Creator Docs: Best practices for data stores (dalam bahasa Inggeris). satu kunci bagi setiap pemain, corak kunci dan simpanan berkala
- Roblox Creator Docs: Data store error codes and limits (dalam bahasa Inggeris). had permintaan bagi setiap pelayan dan had saiz satu nilai
- Roblox Creator Docs: In-game tools (dalam bahasa Inggeris). Handle, anchor, Backpack dan StarterGear
- Roblox Creator Docs: Grid and table layouts (dalam bahasa Inggeris). saiz sel UIGridLayout, jarak dan susunan isihan
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.