Kort fortalt
Lagre hver spillers gjenstander i en tabell på serveren, inne i et ModuleScript i ServerScriptService, og la bare den koden legge til, fjerne og stable dem. Beskriv gjenstandene én gang i et ModuleScript i ReplicatedStorage (id, navn, maks stack). Etter hver endring sender serveren denne spilleren en RemoteEvent med en kopi av inventaret, og et LocalScript tegner det som et rutenett med ScrollingFrame og UIGridLayout.
- Klienten legger aldri til gjenstander. Den kan bare be om noe, for eksempel "utstyr sverdet mitt", og serveren sjekker at spilleren har det før den gjør noe.
- Gjenstander dukker bare opp via serverkode du styrer: plukking, kjøp i butikken etter sjekk på serveren, belønninger.
- Lagre gjenstandenes id og antall, ikke Tool, med DataStoreService når spilleren går ut, når serveren slås av og hvert par minutter. Lagre aldri en spiller hvis data ikke ble lastet.
På denne siden
Slik er inventaret bygd opp
Systemet består av seks små deler, og hver har én oppgave. Alle reglene for gjenstander bor i én servermodul, så når noe går i stykker, er det nøyaktig ett sted å lete.
| Del | Type og plassering | Oppgave |
|---|---|---|
ItemCatalog | ModuleScript i ReplicatedStorage | Hva hver gjenstand er: navn, beskrivelse, maks stack og om den kan utstyres eller brukes. Serveren og alle klientene leser den. |
InventoryService | ModuleScript i ServerScriptService | Holder alle spillernes slots. Den eneste koden som legger til, fjerner og stabler gjenstander. |
InventoryData | Script i ServerScriptService | Laster spillerens gjenstander ved innlogging og lagrer dem. |
InventoryActions | Script i ServerScriptService | Sjekker og utfører forespørsler om utstyring og bruk. |
ItemPickup | Script inne i en Part | Gir gjenstanden til den som plukket den opp. |
InventoryClient | LocalScript i StarterPlayerScripts | Tegner rutenettet og sender forespørsler. Endrer ingenting selv. |
Dataene går én vei. Serveren endrer inventaret, sender så InventoryUpdated med hele inventaret til denne spilleren, og klienten tegner det på nytt. Når spilleren klikker på en slot, sender klienten EquipItem eller UseItem med gjenstandens id; serveren sjekker forespørselen, gjør endringen, og en ny kopi kommer samme vei. Å sende hele inventaret er enklere enn å sende endringer, og for noen titalls slots er meldingen fortsatt liten.
Hvorfor klienten aldri legger til gjenstander
Det er fristende å legge til en gjenstand rett i LocalScript-et som viser den: spilleren klikket, sloten ble fylt. Det går galt på to måter.
- Ingen andre ser det. En endring i et LocalScript finnes bare på den spillerens enhet. Serveren får ikke vite om den, så den lagres ikke, og ingen serverskript kan bruke den.
- Hvem som helst kan forfalske det. Hvis du fikser det med en remote som
AddItem(itemId, amount), kan en juksemaker kalle den hendelsen selv, med hvilke argumenter som helst og så mange ganger hen vil. Roblox sin sikkerhetsguide sier at serveren må sjekke alt klienten sender før det brukes.
Derfor kan klienten i denne guiden bare be om å gjøre noe med gjenstander spilleren allerede har: "utstyr dette" og "bruk dette". Hver forespørsel har én gjenstands-id og ingen antall, og på serveren går den gjennom én sjekk: det er en streng, gjenstanden finnes, spilleren har minst én, og spilleren sender ikke mer enn fire forespørsler i sekundet. Deretter finner serveren selv Tool via katalogen. Den tar aldri imot et Tool, en sti eller en instans fra klienten, noe den samme guiden advarer mot.
Gjenstander havner bare i inventaret via serverkode: en plukking som serveren har sjekket, et kjøp serveren har trukket penger for (det bygges i butikkguiden), en belønning for et oppdrag eller en drop. Om remotes generelt, med sjekk av andre typer argumenter, kan du lese i RemoteEvent-guiden.
Steg 1: gjør klar Explorer
Lag disse objektene for hånd. Skriptene i de neste stegene finner dem etter navn, så skriv hvert navn nøyaktig som her.
- I ReplicatedStorage setter du inn en Folder med navnet
InventoryRemotes. Inni den setter du inn tre RemoteEvent med navneneInventoryUpdated,EquipItemogUseItem. - I ServerStorage setter du inn en Folder med navnet
ItemTools. Inni den setter du inn et Tool med navnetSword, og i Tool en Part med navnetHandle(1 ganger 4 ganger 1 stud holder fint). Sjekk at Anchored ikke er huket av på Handle: Roblox advarer om at karakteren blir sittende fast hvis den holder et verktøy med ankrede parts. Et Tool du allerede har, går også, så lenge navnet stemmer med katalogen fra steg 2. - Legg til skriptene etter hvert som du går gjennom stegene. Treet viser hvor hvert av dem skal.
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
Steg 2: beskriv gjenstandene i katalogen
Katalogen beskriver hver gjenstand som kan finnes, én gang. Inventarene lagrer deretter bare gjenstandens id og antall. Slik holdes lagringene små, og senere kan du gi en gjenstand nytt navn eller skrive om beskrivelsen uten å røre noens lagrede data.
Sett inn et ModuleScript i ReplicatedStorage, kall det ItemCatalog og erstatt innholdet med dette:
-- Alle gjenstandene som kan finnes i spillet. Denne listen leses av serveren og alle
-- klientene; bare serveren bestemmer hvem som har hva.
export type Item = {
id: string, -- må være det samme som nøkkelen under
name: string,
description: string,
maxStack: number, -- hvor mange av denne gjenstanden som får plass i én slot
icon: string?, -- valgfritt bilde: "rbxassetid://" pluss ID-en til bildet ditt
toolName: string?, -- Tool i ServerStorage.ItemTools: gjenstanden kan utstyres
heal: number?, -- hvor mye helse den gir tilbake: gjenstanden er en forbruksvare
}
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 = {}
-- Gir tilbake gjenstanden med denne id-en, eller nil hvis det ikke finnes en slik gjenstand
function ItemCatalog.get(id: string): Item?
return items[id]
end
return ItemCatalog
De valgfrie feltene bestemmer hva en gjenstand gjør. toolName gjør at den kan utstyres, heal gjør at den kan brukes, og en gjenstand uten noen av feltene, som tre, ligger i inventaret til annen serverkode fjerner den (crafting, salg).
For å legge til en gjenstand legger du til en oppføring der nøkkelen og id er like. Id-er skiller mellom store og små bokstaver, og det er de som lagres, så endre aldri en id når spillere allerede har gjenstanden: endre name i stedet.
Steg 3: lagre inventarene på serveren
Dette ModuleScript-et eier inventaret til hver spiller. Hvert inventar er en liste over slots, der hver slot har en gjenstands-id og et antall, pluss en kapasitet på 20 slots. Andre serverskript kaller funksjonene i det, og ingen andre redigerer tabellen.
Sett inn et ModuleScript i ServerScriptService og kall det InventoryService:
-- Den eneste koden som endrer inventarer. Den ligger i ServerScriptService,
-- der klientene verken kan se eller kjøre den.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Strict-modus ser ikke hva require via WaitForChild gir tilbake, så vi
-- beskriver den delen av modulen som dette skriptet bruker
type Item = { id: string, maxStack: number }
type Catalog = { get: (id: string) -> Item? }
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent
export type Slot = { id: string, count: number }
type Inventory = { slots: { Slot }, capacity: number, equipped: string? }
local CAPACITY = 20 -- slots per spiller
local STARTER_ITEMS: { Slot } = { -- det en helt ny spiller starter med
{ id = "sword", count = 1 },
{ id = "apple", count = 3 },
}
local inventories: { [Player]: Inventory } = {}
local InventoryService = {}
-- Sender eieren en kopi av inventaret. Kalles etter hver endring.
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
-- Stackregler: fyll først opp stacks som ikke er fulle, start så nye stacks
-- i tomme slots. Gir tilbake hvor mange som ble lagt til, det kan være færre enn ønsket.
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
-- Hvor mye mer av gjenstanden som får plass: plass i stackene pluss tomme slots
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
-- Legger til opptil amount stykker av gjenstanden. Gir tilbake hvor mange som ble lagt til (0 hvis
-- gjenstanden ikke finnes, inventaret er fullt eller ikke er lastet ennå).
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
-- Fjerner nøyaktig amount stykker av gjenstanden, fra de siste stackene.
-- Hvis spilleren har færre, fjernes ingenting, og false gis tilbake.
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
-- Vi går bakfra, så table.remove ikke hopper over slots
for index = #inventory.slots, 1, -1 do
local slot = inventory.slots[index]
if slot.id == itemId then
local taken = math.min(slot.count, remaining)
slot.count -= taken
remaining -= taken
if slot.count == 0 then
table.remove(inventory.slots, index)
end
if remaining == 0 then
break
end
end
end
sync(player)
return true
end
function InventoryService.getEquipped(player: Player): string?
local inventory = inventories[player]
return if inventory then inventory.equipped else nil
end
function InventoryService.setEquipped(player: Player, itemId: string?)
local inventory = inventories[player]
if inventory then
inventory.equipped = itemId
sync(player)
end
end
-- Kalles når spillerens lagrede data er lastet. saved er det
-- datastoren ga tilbake: nil for en ny spiller. Hver oppføring går på nytt gjennom
-- stackreglene, så slettede gjenstander og gamle stackstørrelser ødelegger ingenting.
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
-- En enkel kopi for lagring, eller nil hvis spillerens data aldri ble lastet
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
Linjene med type og typekonverteringen :: etter require trengs bare av Luau sin typesjekker, som ikke ser hva en modul funnet med WaitForChild gir tilbake. Mens spillet kjører, endrer de ingenting. De andre skriptene i denne guiden gjør det samme.
Slik virker stackreglene med katalogen over, der epler stables opp til 10:
- Legger du til 15 epler hos en spiller med en stack på 7, fylles den stacken opp til 10, og så starter en ny stack på 5.
- Når det er tomt for slots, legger
addtil det som fikk plass og gir tilbake det tallet. KallspaceForførst når du trenger alt eller ingenting, slik plukkingen i steg 5 gjør. removevirker etter prinsippet alt eller ingenting. En forespørsel om 3 epler hos en spiller som har 2, fjerner ingenting og gir tilbakefalse, så sjekk resultatet før du gir noe tilbake.- Det er ingen hull i slotsene: når en slot blir tom, flytter resten seg opp. Slik er listen enklere å sende og lagre. Slots som holder plassen sin, er omtalt i spørsmålene på slutten.
| Funksjon | Gir tilbake | Brukes til |
|---|---|---|
add(player, itemId, amount) | Hvor mange som ble lagt til | Plukking, belønninger, kjøp |
remove(player, itemId, amount) | true hvis alt ble fjernet | Bruk, salg, crafting |
count(player, itemId) | Summen over alle stacks | Sjekke hva spilleren har |
spaceFor(player, itemId) | Hvor mye mer som får plass | Sjekk før tillegg etter prinsippet alt eller ingenting |
getEquipped, setEquipped | Id-en til den utstyrte gjenstanden eller nil | Utstyring, i steg 6 |
load, serialize, unload | En kopi klar til lagring (serialize) | Lasting og lagring, i steg 4 |
Steg 4: last og lagre hvert inventar
Inventarene bor i serverens minne, så de forsvinner når spilleren går ut. Dette skriptet laster spillerens slots fra en datastore når spilleren kommer inn, og skriver dem tilbake når spilleren går ut, når serveren slås av og hvert tredje minutt i tilfelle serveren krasjer. Det lagrer bare gjenstandenes id og antall: datastores kan ikke lagre en Instance, for eksempel et Tool.
Sett inn et Script i ServerScriptService og kall det 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
-- Bare spillere hvis data ble lastet, lagres. Etter en mislykket lasting
-- må vi ikke lagre, ellers erstatter et tomt inventar det ekte.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0
local function keyFor(player: Player): string
return "User_" .. player.UserId
end
-- Én mislykket forespørsel skal ikke koste noen gjenstander, så vi prøver flere ganger.
-- GetDataStore er også inne i pcall, så en Studio-økt uten tilgang til
-- datastores får en advarsel i stedet for å stoppe dette skriptet.
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 -- spilleren gikk ut mens vi lastet
end
if ok then
InventoryService.load(player, saved) -- saved er nil for en ny spiller
canSave[player] = true
elseif RunService:IsStudio() then
-- Betyr vanligvis at Studio sin tilgang til API services er slått av. Vi spiller med
-- startgjenstandene så du kan teste, men lagrer dem aldri.
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 -- dataene ble aldri lastet, det er ingenting som trygt kan skrives
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)
-- Når serveren slås av, lagrer vi alle som fortsatt er her, og venter på hver
-- pågående lagring, også dem PlayerRemoving startet
game:BindToClose(function()
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
while activeSaves > 0 do
task.wait()
end
end)
-- Vi lagrer alle hvert par minutter, så et serverkrasj koster minutter, ikke hele økten
while true do
task.wait(AUTOSAVE_SECONDS)
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
end
Hva skriptet gjør og hvorfor:
- Lasting med standardverdier. En ny spiller har ingen lagret verdi, så
GetAsyncgir tilbake nil, og spilleren får startgjenstandene. Lagrede slots går på nytt gjennom stackreglene, så en gjenstand som er fjernet fra katalogen, eller en mindre maks stack, ødelegger ikke lastingen. Alt som ikke lenger får plass, eller hvis id ikke lenger finnes i katalogen, kastes, og neste lagring gjør det permanent, så behold hver id spillere kan ha i katalogen. - Aldri lagre etter en mislykket lasting. Bare spillere i
canSaveskrives. På en levende server blir en spiller hvis data ikke ble lastet selv etter tre forsøk, bedt om å bli med på nytt. I Studio får spilleren i stedet startgjenstander som ikke lagres, noen sekunder senere på grunn av de nye forsøkene. Slik blir det til placen er publisert med API-tilgang slått på. - Lagring ved utlogging og ved avslutning.
BindToCloselagrer alle som fortsatt er på serveren, og venter på lagringer som allerede pågår. Roblox gir bundne funksjoner opptil 30 sekunder. - Hold deg innenfor grensene. Én skriving per spiller hvert tredje minutt pluss én ved utlogging er langt under standardbudsjettet til en server på 60 skrivinger i minuttet pluss 40 per spiller (ifølge dokumentasjonen per 30. september 2026). Nøkkelmønsteret
User_er hentet fra Roblox sine anbefalinger, og å sende user ID tilSetAsyncknytter dataene til den spilleren, noe Roblox sterkt anbefaler for å håndtere forespørsler om sletting av data.
For et lite spill er dette et solid grunnlag. Sesjonslåsing, som hindrer at en spiller som raskt bytter server, laster dataene før den gamle serveren har lagret dem, og når du skal bruke UpdateAsync i stedet for SetAsync, er gjennomgått i DataStore-guiden.
Steg 5: del ut gjenstander fra verdenen
Plukking er den enkleste måten gjenstander havner i inventaret på: en part med en ProximityPrompt som legger til gjenstanden når spilleren bruker den. Skriptet lytter på Triggered-hendelsen på serveren, så gjenstanden legges til der klienten ikke kan blande seg inn.
- Legg til en Part i Workspace, kall den
Appleog farg den rød. Slå på Anchored og slå av CanCollide, så ingen krasjer i den mens den er usynlig. Prompten viser navnet på parten. - Med parten merket ruller du Properties-vinduet ned til Attributes og klikker +. Legg til
ItemIdav typen string og klikk Save, og sett så verdien tilapple. Legg på samme måte tilAmountav typen number med verdien1. - Sett inn et Script i parten, kall det
ItemPickupog lim inn denne koden:
-- Legg dette Script inne i en Part og gi Part to attributter:
-- ItemId (streng, for eksempel apple) og Amount (tall, for eksempel 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 -- noen andre plukket den opp akkurat nå
end
-- Vi sjekker avstanden på serveren i stedet for å stole på forespørselen
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 -- ikke nok plass: vi lar gjenstanden ligge
end
InventoryService.add(player, itemId, amount)
prompt.Enabled = false
part.Transparency = 1
task.wait(RESPAWN_SECONDS)
part.Transparency = visibleTransparency
prompt.Enabled = true
end)
Kopier parten for å plassere ut flere gjenstander. Endre attributtene for å dele ut tre, et sverd til eller en stack med epler.
Roblox sjekker avstanden for Triggered, men sikkerhetsguiden sier likevel at du skal sjekke prompter på serveren: en juksemaker kan utløse prompthendelser selv når Enabled er false, og kan trekke en part som ikke er ankret, til karakteren sin. Derfor sjekker skriptet selv Enabled og avstanden, og derfor er parten ankret.
Alle andre serverskript deler ut gjenstander på samme måte. Etter et kjøp, et oppdrag eller et drap henter du InventoryService med require, slik skriptene over gjør, og kaller InventoryService.add(player, "wood", 5). Sjekk spaceFor først når gjenstanden ikke må gå tapt. En NPC kan også være en kilde: i guiden om NPC-dialog starter et svar en handling på serveren, og den handlingen kan på samme måte kalle InventoryService.add.
Steg 6: utstyr Tool og bruk gjenstander
To RemoteEvent bærer de eneste forespørslene klienten kan gjøre. EquipItem legger en kopi av gjenstandens Tool fra ServerStorage i spillerens Backpack (hotbaren nederst på skjermen) og i hånden, og en ny forespørsel fjerner den. UseItem fjerner ett stykke av en gjenstand som kan brukes, og gir effekten, her helbredelse.
Sett inn et Script i ServerScriptService og kall det 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 } = {}
-- Hver forespørsel starter her. Klienten kan sende hva som helst når som helst, så
-- vi sjekker typen, at gjenstanden finnes, at spilleren har den, og hvor ofte.
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
-- Ødelegger Tool for denne gjenstanden uansett hvor kopien er: hotbar, hånd eller 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) -- ett utstyrt verktøy om gangen
local tool = template:Clone()
tool.CanBeDropped = false -- en sluppet kopi kunne blitt plukket opp av noen andre
tool:SetAttribute("InventoryItem", item.id)
tool.Parent = backpack
-- En kopi nummer to i StarterGear kopieres tilbake til Backpack etter 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) -- rett i hånden
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) -- et nytt klikk på den utstyrte gjenstanden legger den bort
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 -- død eller allerede på full helse: vi bruker ikke opp gjenstanden
end
-- Først tar vi gjenstanden, og vi helbreder bare hvis det gikk
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)
| Forespørsel | Klienten sender | Serveren sjekker før handlingen |
|---|---|---|
EquipItem | Gjenstandens id | Det er en streng, gjenstanden finnes, spilleren har den, forespørslene kommer ikke oftere enn fire i sekundet, gjenstanden har toolName, og et Tool med det navnet ligger i ServerStorage.ItemTools |
UseItem | Gjenstandens id | De samme sjekkene av type, eierskap og frekvens, gjenstanden har en heal-verdi, karakteren lever og er skadet, og én gjenstand er fjernet før helse legges til |
Tre detaljer hindrer at et Tool blir doblet eller går tapt. Kopien har CanBeDropped satt til false, fordi et sluppet Tool faller ned i Workspace, der en annen spiller kan ta det, mens originalen fortsatt er i inventaret. Hver kopi har attributtet InventoryItem, så når gjenstanden legges bort, kan hver kopi finnes og ødelegges, uansett hvor den er. Og hvis spilleren har en StarterGear-beholder, legges en kopi nummer to i den. Roblox kopierer StarterGear til Backpack hver gang karakteren dukker opp, så et utstyrt sverd kommer tilbake etter respawn.
Bare ett Tool er utstyrt om gangen, og utstyringen lagres ikke, så etter å ha blitt med på nytt starter spilleren med en tom hotbar. Hvis du senere legger til salg eller å kaste gjenstander, legg bort gjenstanden før den siste kopien forlater inventaret.
Plassholdersverdet kan gjøres om til et sverd som faktisk slåss: bygg et Tool etter sverdguiden, behold navnet Sword og legg det i ItemTools i stedet for plassholderen. Serverskriptet fra den guiden sjekker hvert slag, uansett hvordan spilleren fikk sverdet.
Steg 7: tegn inventarrutenettet
LocalScript-et bygger hele vinduet i kode, så du trenger ikke plassere noe for hånd. ScrollingFrame holder slotsene, UIGridLayout inni den legger dem ut i rader, og AutomaticCanvasSize gjør det rullbare området større etter hvert som rader legges til.
I Explorer åpner du StarterPlayer, setter inn et LocalScript i StarterPlayerScripts og kaller det 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. Vi bygger vinduet én gang. ResetOnSpawn = false beholder det etter 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 gjør den større etter cellene
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. Én celle per slot. Dette tegner bare det serveren sendte; selve
-- inventaret endres aldri herfra.
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 -- tom slot
end
local itemId = slot.id
local item = ItemCatalog.get(itemId)
local name = if item then item.name else itemId
if item and item.icon then
local image = Instance.new("ImageLabel")
image.BackgroundTransparency = 1
image.Size = UDim2.fromScale(1, 1)
image.Image = item.icon
image.Parent = cell
else
local nameLabel = makeLabel(cell, name, 14)
nameLabel.Size = UDim2.fromScale(1, 1)
nameLabel.TextWrapped = true
end
if slot.count > 1 then
local countLabel = makeLabel(cell, `x{slot.count}`, 14)
countLabel.AnchorPoint = Vector2.new(1, 1)
countLabel.Position = UDim2.new(1, -6, 1, -4)
countLabel.Size = UDim2.fromOffset(40, 16)
countLabel.TextXAlignment = Enum.TextXAlignment.Right
end
if itemId == equippedId then
local outline = Instance.new("UIStroke")
outline.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
outline.Color = COLOURS.equipped
outline.Thickness = 3
outline.Parent = cell
end
cell.MouseEnter:Connect(function()
info.Text = if item then `{item.name}: {item.description}` else name
end)
cell.Activated:Connect(function()
-- Vi ber, vi befaler ikke: serveren sjekker forespørselen og sender resultatet
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
-- Serveren sender dette etter lasting og etter hver endring
inventoryUpdated.OnClientEvent:Connect(render)
-- 3. Vi åpner og lukker med knappen eller tasten 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)
Et LocalScript i StarterPlayerScripts kjører én gang per økt, og ResetOnSpawn = false beholder ScreenGui når karakteren respawner, så rutenettet fortsetter å vise den siste kopien serveren sendte.
Klienten tegner én celle for hver slot, også de tomme, så et inventar på 20 slots ser alltid ut som 20 slots. Hver oppdatering ødelegger de gamle cellene og bygger nye, det er enkelt og passer for noen titalls slots. Hvis serveren sender InventoryUpdated før dette skriptet har koblet seg til den, setter Roblox meldingen i kø og leverer den så snart handleren kobles til, så det første inventaret går ikke tapt.
Vil du tegne vinduet i Studio? Bygg en ScreenGui med én mal-slot og bruk Clone på den i makeCell. For ikoner gir du gjenstanden i katalogen en icon med et bilde du har lastet opp, så viser cellen bildet i stedet for navnet.
Test inventaret
- Trykk Play. Åpne inventaret med knappen til venstre eller tasten B: en ny spiller har Sword og 3 Apple, og telleren viser 2 / 20 slots. Så lenge Studio ikke kan bruke datastores, dukker gjenstandene opp etter noen sekunder, etter advarsler om lastingen i Output, og de lagres ikke.
- Klikk på Sword. Sverdet dukker opp i hånden din og i hotbaren, og sloten får en lilla ramme. Klikk igjen for å legge det bort.
- Gå bort til Apple-parten og bruk prompten. Eplestacken vokser til 4, og parten forsvinner i 15 sekunder.
- For å teste helbredelsen må du først senke helsen. Bytt Client/Server til Server, merk
Humanoidtil karakteren din i Explorer, sett Health til 50, bytt tilbake til Client og klikk på Apple. - Med Studio sin tilgang til API services slått på stopper du spillet og starter det igjen. Eplet du plukket opp, er der. Hvis lasting eller lagring mislyktes, står det i Output.
For å teste med flere spillere velger du Server & Clients med 2 klienter i testinnstillingene. Hver spiller ser bare sitt eget inventar, og sverdet i hånden til den andre ser begge.
Vanlige feil og løsninger
De fleste problemer vises i Output-vinduet som en advarsel eller en rød feillinje. Les den første: de neste feilene følger ofte av den.
Infinite yield possible på et kall til WaitForChild
Skriptet venter på et objekt som ikke finnes med akkurat det navnet. Sammenlign Explorer med treet fra steg 1: InventoryRemotes med tre RemoteEvent i ReplicatedStorage, ItemTools i ServerStorage og to moduler. Navnene skiller mellom store og små bokstaver. Guiden om skriptfeil går nærmere inn på denne advarselen.
Rutenettet åpnes, men forblir tomt
Klienten tegner bare det serveren sender. Se etter advarsler om Inventory load failed i Output, og sjekk at InventoryData er et Script, ikke et LocalScript, i ServerScriptService, og at ModuleScript-et InventoryService ligger ved siden av. Hvis Output viser feilen Remote event invocation, lytter ingen på InventoryUpdated på klienten: se etter en tidligere feil fra InventoryClient.
Gjenstandene nullstilles hver gang jeg spiller i Studio
Hvis Output skriver Inventory not loaded: playing with starter items that will not be saved, er placen ikke publisert, eller Studio sin tilgang til API services er slått av. Slå den på som beskrevet i steg 4, i en testkopi av spillet ditt.
Å klikke på sverdet gjør ingenting
Se etter Cannot equip sword i Output: Tool i ServerStorage.ItemTools må hete nøyaktig det samme som toolName i katalogen. Et Tool trenger også en part med navnet Handle for å kunne holdes, med mindre du har satt RequiresHandle til false.
Plukkeprompten dukker opp, men ingenting legges til
Attributtet ItemId må være nøyaktig det samme som id-en i katalogen, også store og små bokstaver: apple, ikke Apple. Ingenting legges til mens spillerens inventar fortsatt lastes, eller når det ikke er plass til hele antallet.
Lagringen slutter å virke etter at jeg endret hva som lagres
Datastores tar imot enkle data: strenger, tall, boolske verdier og tabeller av dem. Å lagre et Tool, en Part eller en annen Instance feiler, eller verdien lagres som nil. Lagre gjenstandens id og antall, og gjenopprett resten fra katalogen, slik serialize gjør.
Gjør det med RoCode
Hvis det er enklere for deg å beskrive systemet enn å bygge det for hånd, kan RoCode bygge det i placen du har åpen. Det er en AI-agent for Roblox Studio: du beskriver funksjonen i webchatten, og pluginen for Studio lager skriptene og objektene i Explorer, i stedet for å gi deg kode du må lime inn.
Legg til et inventar med 20 slots og stacks av gjenstander, et rutenett i UI som åpnes med B, et sverd fra ServerStorage som spillerne kan utstyre, epler som helbreder, og lagring med DataStoreService.
- Kan se gjennom placen din når et steg trenger det, med Search Game og Search Scripts, for å bygge på gjenstander, remotes eller lagringskode som allerede finnes, i stedet for å legge til et system nummer to
- Lager mapper og RemoteEvent med Create Instance, og ModuleScript, Script og LocalScript med Create Script
- Kan bygge et utkast til vinduet med Build UI, som har en inventarlayout med plassholder-slots; koden som fyller slotsene fra serveren, skrives i egne skript
- Sjekker at hvert skript kompilerer i Studio med Check Script, som fanger kompileringsfeil og noen risikable mønstre, men ikke sjekker typer, ikke linter og ikke kjører koden din
Hver pakke med endringer er et angrepunkt i Studio. RoCode kan ikke slå på Studio sin tilgang til API services, det gjør du selv. Med plugin 3.9 eller nyere kan den kjøre en kort playtest og lese feilene, og med plugin 3.9.15 eller nyere kan testkarakteren dens trykke på taster og utstyre gjenstander, men den sjekker bare det den selv har bestemt seg for å teste, så test lagringen med en playtest selv. Et inventar bygger på andre systemer, som lagring og verktøy, og AI-spillbyggeren som bygger i din egen place i Studio, legger dem til én prompt om gangen. Slik kobler RoCode seg til Studio.
Ofte stilte spørsmål
Bør jeg bruke Backpack i Roblox i stedet for mitt eget inventar?
Backpack er det innebygde inventaret i Roblox: hvert Tool i det vises som en knapp i hotbaren. Hvis alle gjenstandene i spillet ditt er Tool og du ikke trenger stacks, antall og en grense for slots, kan det holde, selv om du fortsatt må lagre hvilke Tool hver spiller har. Et eget inventar trengs for gjenstander som ikke er Tool, for eksempel materialer og forbruksvarer. Denne guiden bruker begge deler: inventaret holder alt, og Backpack holder det utstyrte Tool.
Hvordan skjuler jeg standard-hotbaren i Roblox?
Kall StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) fra et LocalScript. Når hotbaren er skjult, trenger spillerne en annen måte å ta frem og legge bort det utstyrte Tool på, for eksempel en knapp som ber serveren kalle Humanoid:EquipTool eller Humanoid:UnequipTools.
Hvordan får jeg slots til å holde plassen sin for drag and drop?
Lagre en liste med fast lengde og én oppføring per slot, og merk tomme slots med en verdi som en tom id, ikke nil, fordi Roblox fraråder å sende tabeller med nil via RemoteEvent. Legg så til en RemoteEvent MoveItem som sender to slotnumre, og la serveren sjekke at begge er heltall fra 1 til kapasiteten før de bytter plass.
Hvor stort kan et lagret inventar være?
Én verdi i en datastore kan være opptil 4 194 304 tegn etter serialisering (ifølge dokumentasjonen per 30. september 2026). En liste med id-er og antall tar en bitteliten del av det. Det som får lagringen til å vokse, er tekst per gjenstand, for eksempel egne navn eller lange beskrivelser lagret for hver gjenstand.
Hvordan kjøper og selger jeg gjenstander for mynter?
Gjør alt på serveren. For å selge kaller du InventoryService.remove og betaler bare hvis den ga tilbake true. For å kjøpe sjekker du prisen og spaceFor, trekker myntene og kaller så add. Butikkguiden bygger kjøpssiden.
Kilder og videre lesing
- Roblox Creator Docs: Remote events and callbacks (på engelsk). FireClient, OnServerEvent, begrensninger på argumenter og hvordan meldinger uten mottaker settes i kø
- Roblox Creator Docs: Securing the client-server boundary (på engelsk). sjekk av inndata til remotes, sjekker av ProximityPrompt og forfalskning av data i en datastore
- Roblox Creator Docs: Data stores (på engelsk). GetAsync, SetAsync og hvordan du slår på tilgang fra Studio
- Roblox Creator Docs: Best practices for data stores (på engelsk). én nøkkel per spiller, nøkkelmønstre og jevnlige lagringer
- Roblox Creator Docs: Data store error codes and limits (på engelsk). grenser for forespørsler per server og størrelsesgrensen for én verdi
- Roblox Creator Docs: In-game tools (på engelsk). Handle, ankring, Backpack og StarterGear
- Roblox Creator Docs: Grid and table layouts (på engelsk). cellestørrelse i UIGridLayout, mellomrom og sorteringsrekkefølge
Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.