Kort fortalt
Gem hver spillers ting i en tabel på serveren, inde i et ModuleScript i ServerScriptService, og lad kun den kode tilføje, fjerne og stakke dem. Beskriv tingene én gang i et ModuleScript i ReplicatedStorage (id, navn, maksimal stak). Efter hver ændring sender serveren en RemoteEvent med en kopi af inventaret til den spiller, og et LocalScript tegner det som et gitter med ScrollingFrame og UIGridLayout.
- Klienten tilføjer aldrig ting. Den kan kun bede om noget, for eksempel "udrust mit sværd", og serveren tjekker, at spilleren har det, før den gør noget.
- Ting dukker kun op via server-kode, som du styrer: når de samles op, køb i butikken efter tjek på serveren, belønninger.
- Gem tingenes id og antal, ikke Tools, med DataStoreService, når spilleren går, når serveren lukker, og med nogle minutters mellemrum. Gem aldrig en spiller, hvis data ikke blev indlæst.
På denne side
Sådan er et inventar bygget op
Systemet består af seks små dele, hver med én opgave. Alle regler om ting bor i ét servermodul, så når noget går i stykker, skal du kun lede ét sted.
| Del | Type og placering | Opgave |
|---|---|---|
ItemCatalog | ModuleScript i ReplicatedStorage | Hvad hver ting er: navn, beskrivelse, maksimal stak, og om den kan udrustes eller bruges. Serveren og alle klienter læser det. |
InventoryService | ModuleScript i ServerScriptService | Holder alle spilleres slots. Den eneste kode, der tilføjer, fjerner og stakker ting. |
InventoryData | Script i ServerScriptService | Indlæser spillerens ting ved indgang og gemmer dem. |
InventoryActions | Script i ServerScriptService | Tjekker og udfører forespørgsler om udrustning og brug. |
ItemPickup | Script inde i en Part | Giver tingen til den, der samlede den op. |
InventoryClient | LocalScript i StarterPlayerScripts | Tegner gitteret og sender forespørgsler. Ændrer ikke selv noget. |
Data går i én retning. Serveren ændrer inventaret, sender derefter InventoryUpdated med hele inventaret til den spiller, og klienten tegner det igen. Når spilleren klikker på et slot, sender klienten EquipItem eller UseItem med tingens id; serveren tjekker forespørgslen, laver ændringen, og den nye kopi kommer samme vej. Det er enklere at sende hele inventaret end at sende ændringerne, og til nogle få dusin slots forbliver beskeden lille.
Hvorfor klienten aldrig tilføjer ting
Det er fristende at tilføje en ting direkte i det LocalScript, der viser den: spilleren klikker, og slottet fyldes. Det går i stykker på to måder.
- Ingen andre ser det. En ændring i et LocalScript findes kun på den spillers enhed. Serveren får ikke noget at vide om den, så den bliver ikke gemt, og intet server-script kan bruge den.
- Hvem som helst kan forfalske det. Hvis du løser det med en remote som
AddItem(itemId, amount), kan en snyder selv kalde det event, med hvilke argumenter som helst og så mange gange, han vil. Roblox' guide til sikkerhed siger, at serveren skal tjekke alt, hvad klienten sender, før det bruges.
Derfor kan klienten i denne guide kun bede om at gøre noget med ting, spilleren allerede har: "udrust den her" og "brug den her". Hver forespørgsel har ét id og ingen antal, og på serveren gennemgår den ét tjek: det er en streng, tingen findes, spilleren har mindst én, og spilleren sender højst fire forespørgsler i sekundet. Derefter finder serveren selv Toolet ud fra kataloget. Den tager aldrig imod et Tool, en sti eller en instans fra klienten, som den samme guide advarer om.
Ting kommer kun ind i inventaret via server-kode: en opsamling, som serveren har tjekket, et køb, som serveren har trukket penge for (det bygger guiden til butikker), en belønning for en quest eller et drop. Om remotes generelt, med tjek af andre slags argumenter, kan du læse i guiden til RemoteEvent.
Trin 1: forbered Explorer
Opret disse objekter i hånden. Scriptene i de næste trin leder efter dem via navn, så skriv hvert navn præcis som her.
- Indsæt en Folder med navnet
InventoryRemotesi ReplicatedStorage. Indsæt tre RemoteEvents i den med navneneInventoryUpdated,EquipItemogUseItem. - Indsæt en Folder med navnet
ItemToolsi ServerStorage. Indsæt et Tool med navnetSwordi den, og i Toolet en Part med navnetHandle(1 gange 4 gange 1 studs er helt fint). Tjek, at fluebenet i Anchored er fjernet på Handle: Roblox advarer om, at karakteren sidder fast, hvis den holder et tool med anchored parts. Et Tool, du allerede har, kan også bruges, hvis dets navn passer med kataloget fra trin 2. - Tilføj scriptene, efterhånden som du går gennem trinene. Træet viser, hvor hvert af dem skal ligge.
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
Trin 2: beskriv tingene i et katalog
Kataloget beskriver hver ting, der kan findes, én gang. Inventarerne gemmer derefter kun tingens id og antal. Så forbliver de gemte data små, og du kan senere omdøbe en ting eller omskrive dens beskrivelse uden at røre ved nogens gemte data.
Indsæt et ModuleScript i ReplicatedStorage, kald det ItemCatalog, og erstat indholdet med dette:
-- Alle ting, der kan findes i spillet. Denne liste læses af serveren og alle
-- klienter; kun serveren afgør, hvem der har hvad.
export type Item = {
id: string, -- skal passe med nøglen nedenfor
name: string,
description: string,
maxStack: number, -- hvor mange af denne ting der kan være i ét slot
icon: string?, -- valgfrit billede: "rbxassetid://" plus ID for dit billede
toolName: string?, -- Tool i ServerStorage.ItemTools: tingen kan udrustes
heal: number?, -- hvor meget helbred den giver tilbage: tingen er en forbrugsvare
}
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 = {}
-- Returnerer tingen med dette id eller nil, hvis der ikke findes en sådan ting
function ItemCatalog.get(id: string): Item?
return items[id]
end
return ItemCatalog
De valgfrie felter bestemmer, hvad en ting gør. toolName gør den udrustbar, heal gør den brugbar, og en ting uden begge felter, som træ, ligger i inventaret, indtil anden server-kode fjerner den (crafting, salg).
For at tilføje en ting skal du tilføje en post, hvor nøglen og id er ens. Id skelner mellem store og små bogstaver, og det er dem, der gemmes, så ændr aldrig et id, når spillere allerede har tingen: ændr dens name.
Trin 3: gem inventarerne på serveren
Dette ModuleScript ejer hver spillers inventar. Hvert inventar er en liste af slots, hvert slot med et id og et antal, plus en kapacitet på 20 slots. Andre server-scripts kalder dets funktioner, og ingen andre redigerer tabellen.
Indsæt et ModuleScript i ServerScriptService, og kald det InventoryService:
-- Den eneste kode, der ændrer inventarer. Den ligger i ServerScriptService,
-- hvor klienterne hverken kan se eller køre den.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Strict mode kan ikke se, hvad require via WaitForChild returnerer, så
-- vi beskriver den del af modulet, som dette script bruger
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 pr. 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 ejeren en kopi af inventaret. Kaldes efter hver ændring.
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
-- Regler for stakke: fyld først ufuldstændige stakke op, og start så nye stakke
-- i tomme slots. Returnerer, hvor mange der blev tilføjet, det kan være færre end bedt om.
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 mange flere af tingen der kan være: plads i dens stakke plus 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
-- Tilføjer op til amount stk. af tingen. Returnerer, hvor mange der blev tilføjet (0, hvis
-- tingen ikke findes, inventaret er fuldt eller endnu ikke indlæst).
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 præcis amount stk. af tingen, begyndende med de sidste stakke.
-- Hvis spilleren har færre, fjernes intet, og der returneres false.
function InventoryService.remove(player: Player, itemId: string, amount: number): boolean
local inventory = inventories[player]
local wanted = math.floor(amount)
if not inventory or wanted < 1 or InventoryService.count(player, itemId) < wanted then
return false
end
local remaining = wanted
-- Vi går bagfra, så table.remove ikke springer slots over
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
-- Kaldes, når spillerens gemte data er indlæst. saved er det, som
-- datastore returnerede: nil for en ny spiller. Hver post går igen gennem
-- reglerne for stakke, så fjernede ting og gamle stakstørrelser ikke ødelægger noget.
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 simpel kopi til gemning eller nil, hvis spillerens data aldrig blev indlæst
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
Linjerne med type og castet :: efter require er kun til Luaus typetjekker, som ikke kan se, hvad et modul fundet via WaitForChild returnerer. Under spillet ændrer de ingenting. De andre scripts i denne guide gør det samme.
Sådan virker reglerne for stakke med kataloget ovenfor, hvor æbler stakkes op til 10:
- Hvis du tilføjer 15 æbler til en spiller med en stak på 7, fyldes den stak op til 10, og så starter en ny stak på 5.
- Når der ikke er flere slots, tilføjer
adddet, der var plads til, og returnerer det tal. Kald førstspaceFor, når det skal være alt eller intet, som opsamlingen i trin 5 gør. removevirker efter princippet alt eller intet. En forespørgsel på 3 æbler hos en spiller, der har 2, fjerner intet og returnererfalse, så tjek resultatet, før du giver noget til gengæld.- Der er ingen huller i slots: når et slot bliver tomt, rykker de andre op. Så er listen nemmere at sende og gemme. Slots, der holder deres position, beskrives i spørgsmålene til sidst.
| Funktion | Returnerer | Til hvad |
|---|---|---|
add(player, itemId, amount) | Hvor mange der blev tilføjet | Opsamling, belønninger, køb |
remove(player, itemId, amount) | true, hvis alt blev fjernet | Brug, salg, crafting |
count(player, itemId) | Summen over alle stakke | Tjekke, hvad spilleren har |
spaceFor(player, itemId) | Hvor mange flere der kan være | Tjek før tilføjelse efter princippet alt eller intet |
getEquipped, setEquipped | Id på den udrustede ting eller nil | Udrustning, i trin 6 |
load, serialize, unload | En kopi klar til gemning (serialize) | Indlæsning og gemning, i trin 4 |
Trin 4: indlæs og gem hvert inventar
Inventarer lever i serverens hukommelse, så de forsvinder, når spilleren går. Dette script indlæser spillerens slots fra en datastore, når spilleren kommer ind, og skriver dem tilbage, når spilleren går, når serveren lukker, og hvert tredje minut i tilfælde af et servernedbrud. Det gemmer kun tingenes id og antal: datastores kan ikke gemme en Instance, for eksempel et Tool.
Indsæt et Script i ServerScriptService, og kald 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
-- Kun spillere, hvis data blev indlæst, gemmes. Efter en mislykket indlæsning
-- må der ikke gemmes, ellers erstatter et tomt inventar det rigtige.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0
local function keyFor(player: Player): string
return "User_" .. player.UserId
end
-- Én mislykket forespørgsel må ikke koste nogen deres ting, så vi prøver flere gange.
-- GetDataStore er også inde i pcall, så en Studio-session uden adgang til
-- datastores får en advarsel i stedet for at stoppe dette script.
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 gik, mens vi indlæste
end
if ok then
InventoryService.load(player, saved) -- saved er nil for en ny spiller
canSave[player] = true
elseif RunService:IsStudio() then
-- Betyder som regel, at Studios adgang til API services er slået fra. Vi spiller med
-- startting, så der kan testes, men gemmer dem aldrig.
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 blev aldrig indlæst, der er intet, der er sikkert at skrive
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 lukker, gemmer vi alle, der stadig er her, og venter på hver
-- igangværende gemning, inklusive dem, PlayerRemoving startede
game:BindToClose(function()
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
while activeSaves > 0 do
task.wait()
end
end)
-- Gem alle med nogle minutters mellemrum, så et servernedbrud koster minutter og ikke hele sessionen
while true do
task.wait(AUTOSAVE_SECONDS)
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
end
Hvad scriptet gør, og hvorfor:
- Indlæsning med standardværdier. En ny spiller har ingen gemt værdi, så
GetAsyncreturnerer nil, og spilleren får startting. Gemte slots går igen gennem reglerne for stakke, så en ting, der er fjernet fra kataloget, eller en mindre maksimal stak ikke ødelægger indlæsningen. Alt, der ikke længere er plads til, eller hvis id ikke længere findes i kataloget, smides væk, og den næste gemning gør det endeligt, så behold hvert id, som spillere kan have, i kataloget. - Gem aldrig efter en mislykket indlæsning. Kun spillere i
canSavebliver skrevet. På en rigtig server bliver en spiller, hvis data ikke blev indlæst selv efter tre forsøg, bedt om at komme ind igen. I Studio får spilleren i stedet startting, der ikke gemmes, nogle sekunder senere på grund af de gentagne forsøg. Sådan er det, indtil dit place er udgivet med adgang til API slået til. - Gemning ved udgang og ved lukning.
BindToClosegemmer alle, der stadig er på serveren, og venter på gemninger, der allerede er i gang. Roblox giver bundne funktioner op til 30 sekunder. - Hold dig inden for grænserne. Én skrivning pr. spiller hvert tredje minut plus én ved udgang er langt under en servers standardbudget på 60 skrivninger i minuttet plus 40 for hver spiller (ifølge dokumentationen pr. 30. september 2026). Nøglemønsteret
User_kommer fra Roblox' anbefalinger, og at sende user ID med iSetAsyncknytter dataene til den spiller, hvilket Roblox kraftigt anbefaler for at kunne håndtere anmodninger om sletning af data.
Til et lille spil er det et solidt fundament. Session locking, som forhindrer en spiller, der hurtigt skifter server, i at indlæse data, før den gamle server har gemt dem, og hvornår du skal bruge UpdateAsync i stedet for SetAsync, gennemgås i tutorialen om DataStore.
Trin 5: giv ting fra verden
Opsamling er den enkleste måde, ting kommer ind i inventaret på: en part med en ProximityPrompt, der tilføjer tingen, når spilleren bruger den. Scriptet lytter efter dens event Triggered på serveren, så tingen tilføjes dér, hvor klienten ikke kan blande sig.
- Tilføj en Part i Workspace, kald den
Apple, og farv den rød. Slå Anchored til og CanCollide fra, så ingen støder ind i den, mens den er usynlig. Prompten viser partens navn. - Med parten markeret skal du rulle ned i vinduet Properties til afsnittet Attributes og klikke på +. Tilføj
ItemIdaf typen string, klik på Save, og sæt derefter værdien tilapple. Tilføj på samme mådeAmountaf typen number med værdien1. - Indsæt et Script i parten, kald det
ItemPickup, og sæt denne kode ind:
-- Læg dette Script inde i en Part, og giv parten to attributter:
-- ItemId (en streng, for eksempel apple) og Amount (et tal, 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 -- en anden har lige samlet den op
end
-- Tjek afstanden på serveren i stedet for at stole på forespørgslen
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 plads nok: lad tingen blive liggende
end
InventoryService.add(player, itemId, amount)
prompt.Enabled = false
part.Transparency = 1
task.wait(RESPAWN_SECONDS)
part.Transparency = visibleTransparency
prompt.Enabled = true
end)
Kopiér parten for at placere flere ting. Ændr attributterne for at give træ, endnu et sværd eller en stak æbler.
Roblox tjekker afstanden for Triggered, men dets guide til sikkerhed siger alligevel, at du skal tjekke prompts på serveren: en snyder kan udløse promptens events, selv når Enabled er false, og kan trække en part, der ikke er anchored, hen til sin karakter. Derfor tjekker scriptet selv Enabled og afstanden, og derfor er parten anchored.
Ethvert andet server-script giver ting på samme måde. Efter et køb, en quest eller et drab skal du hente InventoryService med require, som scriptene ovenfor, og kalde InventoryService.add(player, "wood", 5). Tjek først spaceFor, når tingen ikke må gå tabt. En NPC kan også være en kilde: i guiden til NPC-dialoger starter et svar en handling på serveren, og den handling kan på samme måde kalde InventoryService.add.
Trin 6: udrust Tools og brug ting
To RemoteEvents bærer de eneste forespørgsler, klienten kan sende. EquipItem lægger en kopi af tingens Tool fra ServerStorage i spillerens Backpack (hotbaren nederst på skærmen) og i spillerens hånd, og en ny forespørgsel lægger den væk. UseItem fjerner ét stk. af en brugbar ting og anvender dens effekt, her heling.
Indsæt et Script i ServerScriptService, og kald 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ørgsel starter her. Klienten kan sende hvad som helst når som helst, så
-- vi tjekker typen, at tingen findes, at spilleren har den, og hyppigheden.
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
-- Ødelægger tingens Tool, hvor kopien end 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) -- ét udrustet tool ad gangen
local tool = template:Clone()
tool.CanBeDropped = false -- en tabt kopi kunne samles op af en anden
tool:SetAttribute("InventoryItem", item.id)
tool.Parent = backpack
-- En ekstra kopi i StarterGear kopieres tilbage til Backpack efter 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) -- direkte 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 nyt klik på den udrustede ting lægger den væk
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 med fuldt helbred: spild ikke tingen
end
-- Tag først tingen, og hel kun, hvis det lykkedes
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ørgsel | Klienten sender | Serveren tjekker før handlingen |
|---|---|---|
EquipItem | Tingens id | Det er en streng, tingen findes, spilleren har den, forespørgslerne kommer højst fire gange i sekundet, tingen har et toolName, og et Tool med det navn ligger i ServerStorage.ItemTools |
UseItem | Tingens id | De samme tjek af type, ejerskab og hyppighed, tingen har en værdi heal, karakteren er i live og såret, og én ting er fjernet, før helbredet lægges til |
Tre detaljer forhindrer et Tool i at blive fordoblet eller gå tabt. Kopien har CanBeDropped sat til false, fordi et tabt Tool falder ned i Workspace, hvor en anden spiller kan tage det, mens originalen bliver i inventaret. Hver kopi har attributten InventoryItem, så du ved aflægning kan finde og ødelægge hver kopi, hvor den end er. Og hvis spilleren har en container StarterGear, lægges en ekstra kopi i den. Roblox kopierer StarterGear til Backpack, hver gang karakteren dukker op, så et udrustet sværd kommer tilbage efter respawn.
Kun ét Tool er udrustet ad gangen, og udrustningen gemmes ikke, så spilleren starter med en tom hotbar efter at være kommet ind igen. Hvis du senere tilføjer salg eller at smide ting væk, så aflæg tingen, før dens sidste kopi forlader inventaret.
Pladsholder-sværdet kan gøres til et sværd, der virkelig kæmper: byg Toolet med guiden til sværd, behold navnet Sword, og læg det i ItemTools i stedet for pladsholderen. Server-scriptet fra den guide tjekker hvert slag, uanset hvordan spilleren har fået sværdet.
Trin 7: tegn inventargitteret
LocalScriptet bygger hele vinduet i kode, så intet skal placeres i hånden. ScrollingFrame holder slots, UIGridLayout inde i den lægger dem i rækker, og AutomaticCanvasSize gør det rullbare område større, efterhånden som der kommer flere rækker.
Åbn StarterPlayer i Explorer, indsæt et LocalScript i StarterPlayerScripts, og kald 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. Byg vinduet én gang. ResetOnSpawn = false bevarer det efter respawns.
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 gør det større, så cellerne passer
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 pr. slot. Dette tegner kun det, serveren sendte; selve
-- inventaret ændres aldrig 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 -- tomt 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()
-- Bed i stedet for at beordre: serveren tjekker forespørgslen 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 efter indlæsning og efter hver ændring
inventoryUpdated.OnClientEvent:Connect(render)
-- 3. Åbn og luk 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 kører én gang pr. session, og ResetOnSpawn = false bevarer ScreenGuien, når karakteren respawner, så gitteret fortsat viser den sidste kopi, serveren sendte.
Klienten tegner én celle for hvert slot, også de tomme, så et inventar med 20 slots altid ser ud som 20 slots. Hver opdatering ødelægger de gamle celler og bygger nye, det er enkelt og passer til nogle få dusin slots. Hvis serveren sender InventoryUpdated, før dette script har forbundet sig til det, sætter Roblox beskeden i kø og leverer den, så snart handleren er forbundet, så det første inventar ikke går tabt.
Vil du tegne vinduet i Studio? Byg en ScreenGui med ét skabelon-slot, og lav Clone af det i makeCell. Til ikoner skal du give tingen i kataloget et icon med et billede, du selv har uploadet, så viser dens celle billedet i stedet for navnet.
Test inventaret
- Tryk på Play. Åbn inventaret med knappen til venstre eller tasten B: en ny spiller har Sword og 3 Apple, og tælleren viser 2 / 20 slots. Så længe Studio ikke kan bruge datastores, dukker tingene op efter nogle sekunder, efter advarsler om indlæsning i Output, og bliver ikke gemt.
- Klik på Sword. Sværdet dukker op i din hånd og i hotbaren, og dets slot får en lilla ramme. Klik igen for at lægge det væk.
- Gå hen til parten Apple, og brug dens prompt. Stakken af æbler vokser til 4, og parten forsvinder i 15 sekunder.
- For at teste heling skal du først sænke helbredet. Skift Client/Server til Server, markér din karakters
Humanoidi Explorer, sæt Health til 50, skift tilbage til Client, og klik på Apple. - Med Studios adgang til API services slået til skal du stoppe spillet og starte det igen. Det opsamlede æble er der stadig. Hvis indlæsning eller gemning mislykkedes, siger Output det.
For at teste med flere spillere skal du vælge Server & Clients med 2 klienter i testindstillingerne. Hver spiller ser kun sit eget inventar, og et sværd i den andens hånd ser begge.
Almindelige fejl og løsninger
De fleste problemer kan ses i vinduet Output som en advarsel eller en rød fejllinje. Læs den første: de følgende fejl skyldes ofte den.
Infinite yield possible på et kald til WaitForChild
Scriptet venter på et objekt, der ikke findes med præcis det navn. Sammenlign din Explorer med træet fra trin 1: InventoryRemotes med tre RemoteEvents i ReplicatedStorage, ItemTools i ServerStorage og to moduler. Navne skelner mellem store og små bogstaver. Guiden til script-fejl gennemgår denne advarsel nærmere.
Gitteret åbner, men forbliver tomt
Klienten tegner kun det, serveren sender. Kig efter advarsler Inventory load failed i Output, og tjek, at InventoryData er et Script og ikke et LocalScript i ServerScriptService, og at ModuleScriptet InventoryService ligger ved siden af. Hvis Output viser fejlen Remote event invocation, er der ingen på klienten, der lytter efter InventoryUpdated: kig efter en tidligere fejl fra InventoryClient.
Tingene nulstilles, hver gang jeg spiller i Studio
Hvis Output skriver Inventory not loaded: playing with starter items that will not be saved, er dit place ikke udgivet, eller Studios adgang til API services er slået fra. Slå den til som beskrevet i trin 4, i en testkopi af dit spil.
Et klik på sværdet gør ingenting
Kig efter Cannot equip sword i Output: Toolet i ServerStorage.ItemTools skal hedde præcis som toolName i kataloget. Toolet skal også have en part med navnet Handle, så det kan holdes, medmindre du har sat dets RequiresHandle til false.
Opsamlingsprompten dukker op, men intet bliver tilføjet
Attributten ItemId skal passe præcis med id i kataloget, inklusive store og små bogstaver: apple, ikke Apple. Intet bliver tilføjet, mens spillerens inventar stadig indlæses, eller når der ikke er plads til hele antallet.
Gemning går i stykker, efter at jeg ændrede, hvad der gemmes
Datastores tager imod simple data: strenge, tal, booleans og tabeller af dem. At gemme et Tool, en Part eller en anden Instance mislykkes, eller værdien gemmes som nil. Gem tingens id og antal, og genskab resten ud fra kataloget, som serialize gør.
Lav det med RoCode
Hvis det er nemmere for dig at beskrive systemet end at bygge det i hånden, kan RoCode bygge det i det place, du har åbent. Det er en AI-agent til Roblox Studio: du beskriver funktionen i webchatten, og dens Studio-plugin opretter scripts og objekter i din Explorer i stedet for at give dig kode, du skal sætte ind.
Tilføj et inventar med 20 slots og stakke af ting, et UI-gitter, der åbner med B, et sværd fra ServerStorage, som spillerne kan udruste, æbler, der heler, og gemning med DataStoreService.
- Kan gennemse dit place, når et trin kræver det, med Search Game og Search Scripts, så den bygger på eksisterende ting, remotes eller gemmekode i stedet for at tilføje et ekstra system
- Opretter mapper og RemoteEvents med Create Instance og ModuleScripts, Scripts og LocalScripts med Create Script
- Kan bygge et udkast til vinduet med Build UI, som har et inventarlayout med pladsholder-slots; koden, der udfylder slots fra serveren, skrives i separate scripts
- Tjekker kompileringen af hvert script i Studio med Check Script, som fanger kompileringsfejl og nogle risikable mønstre, men ikke tjekker typer, ikke linter og ikke kører din kode
Hver omgang ændringer er et fortryd-punkt i Studio. RoCode kan ikke slå Studios adgang til API services til, det gør du selv. Med plugin 3.9 eller nyere kan den køre en kort playtest og læse fejlene, og med plugin 3.9.15 eller nyere kan dens testkarakter trykke på taster og udruste ting, men den tjekker kun det, den selv har valgt at teste, så test selv gemningen med en playtest. Et inventar ligger oven på andre systemer, som gemning og tools, og AI-spilbyggeren, der bygger i dit eget place i Studio, tilføjer dem én prompt ad gangen. Sådan forbinder RoCode til Studio.
Ofte stillede spørgsmål
Skal jeg bruge Backpack i Roblox i stedet for mit eget inventar?
Backpack er Roblox' indbyggede inventar: hvert Tool i det vises som en knap i hotbaren. Hvis alle ting i dit spil er Tools, og du ikke har brug for stakke, antal og en grænse for slots, kan den være nok, selvom du stadig skal gemme, hvilke Tools hver spiller har. Et eget inventar skal bruges til ting, der ikke er Tools, for eksempel materialer og forbrugsvarer. Denne guide bruger begge: inventaret holder alt, og Backpack holder det udrustede Tool.
Hvordan skjuler man standard-hotbaren i Roblox?
Kald StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) fra et LocalScript. Når hotbaren er skjult, skal spillerne have en anden måde at tage og lægge et udrustet Tool væk på, for eksempel en knap, der beder serveren om at kalde Humanoid:EquipTool eller Humanoid:UnequipTools.
Hvordan får man slots til at holde deres position til drag and drop?
Gem en liste med fast længde med én post pr. slot, og markér tomme slots med en værdi som et tomt id i stedet for nil, fordi Roblox fraråder at sende tabeller med nil via en RemoteEvent. Tilføj derefter en RemoteEvent MoveItem, der sender to slotnumre, og lad serveren tjekke, at begge er heltal fra 1 til kapaciteten, før de byttes om.
Hvor stort kan et gemt inventar være?
Én værdi i en datastore kan fylde op til 4 194 304 tegn efter serialisering (ifølge dokumentationen pr. 30. september 2026). En liste med id og antal fylder en lillebitte del af det. Det, der får gemningen til at vokse, er tekst for hver ting, for eksempel egne navne eller lange beskrivelser gemt for hver ting.
Hvordan køber og sælger man ting for mønter?
Gør alt på serveren. For at sælge skal du kalde InventoryService.remove og kun betale, hvis den returnerede true. For at købe skal du tjekke prisen og spaceFor, tage mønterne og derefter kalde add. Guiden til butikker bygger købssiden.
Kilder og videre læsning
- Roblox Creator Docs: Remote events and callbacks (på engelsk). FireClient, OnServerEvent, begrænsninger for argumenter, og hvordan beskeder uden modtager sættes i kø
- Roblox Creator Docs: Securing the client-server boundary (på engelsk). tjek af input til remotes, tjek af ProximityPrompt og manipulation af data i datastore
- Roblox Creator Docs: Data stores (på engelsk). GetAsync, SetAsync og adgang fra Studio
- Roblox Creator Docs: Best practices for data stores (på engelsk). én nøgle pr. spiller, nøglemønstre og periodisk gemning
- Roblox Creator Docs: Data store error codes and limits (på engelsk). grænser for forespørgsler pr. server og grænsen for størrelsen af én værdi
- Roblox Creator Docs: In-game tools (på engelsk). Handle, anchoring, Backpack og StarterGear
- Roblox Creator Docs: Grid and table layouts (på engelsk). cellestørrelse, afstand og sorteringsrækkefølge i UIGridLayout
Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.