Guide · Spelsystem

Så gör du ett inventarie i Roblox Studio

Ett inventarie ser ut som en uppgift om gränssnittet, men om det går att hacka och om det tappar föremål avgörs av var föremålen sparas. I den här guiden ligger varje spelares föremål i en tabell på servern, varje spelare får en kopia och ritar den som ett rutnät, utrustar Tool och använder förbrukningsvaror via förfrågningar som servern kontrollerar, och allt sparas i ett datalager.

Uppdaterad 20 november 202616 min läsningSkriven av

I korthet

Spara varje spelares föremål i en tabell på servern, inuti ett ModuleScript i ServerScriptService, och låt bara den koden lägga till, ta bort och stapla dem. Beskriv föremålen en gång i ett ModuleScript i ReplicatedStorage (id, namn, största stack). Efter varje ändring skickar servern ett RemoteEvent till den spelaren med en kopia av spelarens inventarie, och ett LocalScript ritar det som ett rutnät med ScrollingFrame och UIGridLayout.

  • Klienten lägger aldrig till föremål. Den kan bara be om något, till exempel "utrusta mitt svärd", och servern kontrollerar att spelaren har det innan något görs.
  • Föremål dyker bara upp via serverkod som du har kontroll över: upplockning, köp i en butik efter kontroll på servern, belöningar.
  • Spara föremålens id och antal, inte Tool, med DataStoreService när spelaren lämnar, när servern stängs av och med några minuters mellanrum. Spara aldrig en spelare vars data inte laddades.
På den här sidan
  1. Så är det uppbyggt
  2. Varför föremål på servern
  3. 1. Förbered Explorer
  4. 2. Föremålskatalog
  5. 3. Inventariet på servern
  6. 4. Laddning och sparande
  7. 5. Plocka upp föremål
  8. 6. Utrusta och använda
  9. 7. UI-rutnät
  10. Testa
  11. Common errors
  12. Med RoCode
  13. Vanliga frågor
  14. Källor och vidare läsning

Så är inventariet uppbyggt

IllustrationTryck på B, för muspekaren över ett föremål för att läsa beskrivningen, och klicka på Sword för att ta det i handen.

Systemet består av sex små delar, var och en med en uppgift. Alla regler om föremål finns i en enda servermodul, så när något går sönder behöver du bara leta på ett ställe.

Systemets delar och var de körs
DelTyp och platsUppgift
ItemCatalogModuleScript i ReplicatedStorageVad varje föremål är: namn, beskrivning, största stack och om det kan utrustas eller användas. Läses av servern och alla klienter.
InventoryServiceModuleScript i ServerScriptServiceHåller alla spelares platser. Den enda kod som lägger till, tar bort och staplar föremål.
InventoryDataScript i ServerScriptServiceLaddar spelarens föremål när spelaren går in och sparar dem.
InventoryActionsScript i ServerScriptServiceKontrollerar och utför förfrågningar om att utrusta och använda.
ItemPickupScript inuti en PartGer föremålet till den som plockade upp det.
InventoryClientLocalScript i StarterPlayerScriptsRitar rutnätet och skickar förfrågningar. Ändrar ingenting själv.

Datan går åt ett håll. Servern ändrar inventariet, skickar sedan InventoryUpdated med hela inventariet till den spelaren, och klienten ritar om det. När spelaren klickar på en plats skickar klienten EquipItem eller UseItem med föremålets id; servern kontrollerar förfrågan, gör ändringen, och den nya kopian kommer tillbaka samma väg. Att skicka hela inventariet är enklare än att skicka ändringar, och för några dussin platser förblir meddelandet litet.

Varför klienten aldrig lägger till föremål

Det är frestande att lägga till ett föremål direkt i det LocalScript som visar det: spelaren klickade, platsen fylldes. Det går sönder på två sätt.

  • Ingen annan ser det. En ändring i ett LocalScript finns bara på den spelarens enhet. Servern får aldrig veta om den, så den sparas inte, och inget serverskript kan använda den.
  • Vem som helst kan förfalska det. Om du lagar det med en remote som AddItem(itemId, amount) kan en fuskare själv avfyra det eventet, med vilka argument som helst och hur många gånger som helst. Roblox säkerhetsguide säger att servern måste kontrollera allt som klienten skickar innan det används.

Därför kan klienten i den här guiden bara be om att något görs med föremål som spelaren redan har: "utrusta det här" och "använd det här". Varje förfrågan innehåller ett föremåls-id och inga antal, och på servern går den igenom en enda kontroll: det är en sträng, ett sådant föremål finns, spelaren har minst ett, och spelaren skickar högst fyra förfrågningar per sekund. Sedan hittar servern själv Tool via katalogen. Den tar aldrig emot ett Tool, en sökväg eller en instans från klienten, något som samma guide varnar för.

Föremål hamnar bara i inventariet via serverkod: en upplockning som servern har kontrollerat, ett köp som servern har dragit pengar för (det bygger guiden om butiker), en belöning för ett uppdrag eller en drop. Om remotes i allmänhet, med kontroll av andra sorters argument, kan du läsa i guiden om RemoteEvent.

Steg 1: förbered Explorer

Skapa de här objekten för hand. Skripten i de följande stegen hittar dem via namn, så skriv varje namn exakt som här.

  1. Lägg in en Folder med namnet InventoryRemotes i ReplicatedStorage. Lägg in tre RemoteEvent i den med namnen InventoryUpdated, EquipItem och UseItem.
  2. Lägg in en Folder med namnet ItemTools i ServerStorage. Lägg in ett Tool med namnet Sword i den, och i Tool en Part med namnet Handle (1 gånger 4 gånger 1 stud räcker gott). Kontrollera att Anchored inte är ikryssad på Handle: Roblox varnar för att karaktären fastnar på stället om den håller ett verktyg med Anchored-parts. Ett Tool som du redan har fungerar också, om dess namn stämmer med katalogen i steg 2.
  3. Lägg till skripten allteftersom du går igenom stegen. Trädet visar var vart och ett ska ligga.
Explorer när guiden är klar
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 föremålen i katalogen

Katalogen beskriver varje föremål som kan finnas, en gång. Inventarierna sparar sedan bara föremålets id och antal. Så förblir sparfilerna små, och senare kan du byta namn på ett föremål eller skriva om dess beskrivning utan att röra någons sparade data.

Lägg in ett ModuleScript i ReplicatedStorage, döp det till ItemCatalog och ersätt dess innehåll med det här:

ModuleScript i ReplicatedStorage med namnet ItemCatalog
-- Alla föremål som kan finnas i spelet. Den här listan läses av servern och alla
-- klienter; bara servern bestämmer vem som har vad.
export type Item = {
	id: string, -- måste stämma med nyckeln nedan
	name: string,
	description: string,
	maxStack: number, -- hur många av föremålet som ryms i en plats
	icon: string?, -- valfri bild: "rbxassetid://" plus ID:t för din bild
	toolName: string?, -- Tool i ServerStorage.ItemTools: föremålet kan utrustas
	heal: number?, -- hur mycket hälsa det återställer: föremålet är förbrukningsbart
}

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

-- Returnerar föremålet med det här id:t, eller nil om det inte finns något sådant föremål
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

De valfria fälten avgör vad ett föremål gör. toolName gör det utrustningsbart, heal gör det användbart, och ett föremål utan båda fälten, som trä, ligger i inventariet tills annan serverkod tar bort det (tillverkning, försäljning).

För att lägga till ett föremål lägger du till en post där nyckeln och id är samma. Id:n skiljer på stora och små bokstäver och är det som sparas, så ändra aldrig ett id när spelare redan har föremålet: ändra dess name.

Steg 3: håll inventarierna på servern

Det här ModuleScript äger varje spelares inventarie. Varje inventarie är en lista med platser, där varje plats har ett föremåls-id och ett antal, plus en kapacitet på 20 platser. Andra serverskript anropar dess funktioner, och ingen annan redigerar tabellen.

Lägg in ett ModuleScript i ServerScriptService och döp det till InventoryService:

ModuleScript i ServerScriptService med namnet InventoryService
-- Den enda kod som ändrar inventarier. Den ligger i ServerScriptService,
-- där klienter varken kan se eller köra den.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Strict-läget ser inte vad require via WaitForChild returnerar, så
-- vi beskriver den del av modulen som det här skriptet använder
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 -- platser per spelare
local STARTER_ITEMS: { Slot } = { -- det som en helt ny spelare börjar med
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Skickar en kopia av inventariet till ägaren. Anropas efter varje ä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

-- Stackregler: fyll först på ofullständiga stackar, börja sedan nya stackar
-- i tomma platser. Returnerar hur många som lades till, vilket kan vara färre än begärt.
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

-- Hur många till av föremålet som ryms: plats i dess stackar plus tomma platser
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

-- Lägger till upp till amount av ett föremål. Returnerar hur många som lades till (0 om
-- föremålet inte finns, inventariet är fullt eller inte har laddats än).
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

-- Tar bort exakt amount av ett föremål, med början i de sista stackarna.
-- Om spelaren har färre tas ingenting bort och false returneras.
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
	-- Gå bakifrån, så att table.remove inte hoppar över platser
	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

-- Anropas när spelarens sparade data har laddats. saved är det som
-- datalagret returnerade: nil för en ny spelare. Varje post går igenom
-- stackreglerna igen, så borttagna föremål och gamla stackstorlekar förstör 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 kopia att spara, eller nil om spelarens data aldrig laddades
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

Raderna type och typomvandlingen :: efter require behövs bara för Luaus typkontroll, som inte ser vad en modul som hittats via WaitForChild returnerar. Under spelet ändrar de ingenting. De andra skripten i den här guiden gör likadant.

Så fungerar stackreglerna med katalogen ovan, där äpplen staplas upp till 10:

  • Om du lägger till 15 äpplen till en spelare med en stack på 7 fylls den stacken upp till 10, och sedan börjar en ny stack på 5.
  • När platserna tar slut lägger add till det som fick plats och returnerar det antalet. Anropa spaceFor först när det ska vara allt eller inget, som upplockningen i steg 5 gör.
  • remove fungerar enligt principen allt eller inget. En begäran om 3 äpplen från en spelare som har 2 tar inte bort något och returnerar false, så kontrollera resultatet innan du ger något i utbyte.
  • Det finns inga hål i platserna: när en plats blir tom flyttas resten upp. Så blir listan enklare att skicka och spara. Om platser som behåller sin position berättar vi i frågorna i slutet.
Vad andra serverskript kan anropa
FunktionReturnerarTill vad
add(player, itemId, amount)Hur många som lades tillUpplockning, belöningar, köp
remove(player, itemId, amount)true om allt togs bortAnvända, sälja, tillverka
count(player, itemId)Summan av alla stackarKontrollera vad spelaren har
spaceFor(player, itemId)Hur många till som rymsKontroll innan tillägg enligt principen allt eller inget
getEquipped, setEquippedId för det utrustade föremålet eller nilUtrustning, i steg 6
load, serialize, unloadEn kopia redo att sparas (serialize)Laddning och sparande, i steg 4

Steg 4: ladda och spara varje inventarie

Inventarierna finns i serverns minne, så de försvinner när spelaren lämnar. Det här skriptet laddar spelarens platser från ett datalager när spelaren går in, och skriver tillbaka dem när spelaren lämnar, när servern stängs av och var tredje minut ifall servern kraschar. Det sparar bara föremålens id och antal: datalager kan inte spara en Instance, till exempel ett Tool.

Lägg in ett Script i ServerScriptService och döp det till InventoryData:

Script i ServerScriptService med namnet 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

-- Bara spelare vars data har laddats sparas. Efter en misslyckad laddning
-- får man inte spara, annars ersätter ett tomt inventarie det riktiga.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- En misslyckad förfrågan ska inte kosta någon föremål, så vi försöker flera gånger.
-- GetDataStore ligger också i pcall, så en Studio-session utan åtkomst till data
-- stores får en varning i stället för att stoppa det här 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 -- spelaren lämnade medan vi laddade
	end
	if ok then
		InventoryService.load(player, saved) -- saved är nil för en ny spelare
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Betyder oftast att Studios åtkomst till API services är avstängd. Spela med
		-- startföremålen så att det går att testa, men spara 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 -- datan laddades aldrig, det finns inget som är säkert att skriva
	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 servern stängs av sparar vi alla som fortfarande är kvar och väntar på varje
-- pågående sparning, även de som PlayerRemoving startade
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Spara alla med några minuters mellanrum, så att en serverkrasch kostar minuter, inte hela sessionen
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Vad skriptet gör och varför:

  • Laddning med standardvärden. En ny spelare har inget sparat värde, så GetAsync returnerar nil, och spelaren får startföremålen. Sparade platser går igenom stackreglerna igen, så ett föremål som tagits bort från katalogen eller en minskad största stack förstör inte laddningen. Allt som inte längre ryms eller vars id inte längre finns i katalogen kastas, och nästa sparning gör det permanent, så behåll varje id som spelare kan ha i katalogen.
  • Spara aldrig efter en misslyckad laddning. Bara spelare i canSave skrivs. På en riktig server ombeds en spelare vars data inte laddades ens efter tre försök att gå in igen. I Studio får spelaren i stället startföremål som inte sparas, några sekunder senare på grund av de nya försöken. Så blir det tills din place är publicerad med API-åtkomst påslagen.
  • Sparar när spelaren lämnar och vid avstängning. BindToClose sparar alla som fortfarande är på servern och väntar på sparningar som redan pågår. Roblox ger bundna funktioner upp till 30 sekunder.
  • Håll dig inom gränserna. En skrivning per spelare var tredje minut plus en när spelaren lämnar är mycket mindre än serverns standardbudget på 60 skrivningar per minut plus 40 per spelare (enligt dokumentationen den 30 september 2026). Nyckelmönstret User_ kommer från Roblox rekommendationer, och att skicka user ID till SetAsync kopplar datan till den spelaren, vilket Roblox starkt rekommenderar för att hantera begäranden om att radera data.

För ett litet spel är det här en stabil grund. Sessionslåsning, som hindrar en spelare som snabbt bytt server från att ladda data innan den gamla servern har sparat den, och när du ska använda UpdateAsync i stället för SetAsync, går vi igenom i guiden om DataStore.

Steg 5: ge föremål från världen

Upplockning är det enklaste sättet för föremål att hamna i inventariet: en part med en ProximityPrompt som lägger till föremålet när spelaren använder den. Skriptet lyssnar på dess händelse Triggered på servern, så föremålet läggs till där klienten inte kan lägga sig i.

  1. Lägg till en Part i Workspace, döp den till Apple och färga den röd. Slå på Anchored och stäng av CanCollide, så att ingen krockar med den medan den är osynlig. Prompten visar partens namn.
  2. Med parten markerad skrollar du i fönstret Properties ner till avsnittet Attributes och klickar på +. Lägg till ItemId med typen string och klicka på Save, och sätt sedan värdet till apple. Lägg till Amount av typen number med värdet 1 på samma sätt.
  3. Lägg in ett Script i parten, döp det till ItemPickup och klistra in den här koden:
Script i Apple-parten i Workspace med namnet ItemPickup
-- Lägg det här Script inuti en Part och ge Part två attribut:
-- ItemId (en sträng, till exempel apple) och Amount (ett tal, till exempel 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 -- någon annan plockade precis upp det
	end
	-- Kontrollera avståndet på servern i stället för att lita på förfrågan
	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 -- inte tillräckligt med plats: lämna föremålet där det är
	end
	InventoryService.add(player, itemId, amount)

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

Kopiera parten för att placera ut fler föremål. Ändra attributen för att ge trä, ett svärd till eller en stack äpplen.

Roblox kontrollerar avståndet för Triggered, men dess säkerhetsguide säger ändå att prompter ska kontrolleras på servern: en fuskare kan utlösa promptens händelser även när Enabled är false, och kan dra en part som inte är Anchored till sin karaktär. Därför kontrollerar skriptet själv Enabled och avståndet, och därför är parten Anchored.

Alla andra serverskript ger föremål på samma sätt. Efter ett köp, ett uppdrag eller en dödad fiende hämtar du InventoryService med require, som skripten ovan, och anropar InventoryService.add(player, "wood", 5). Kontrollera spaceFor först när föremålet inte får gå förlorat. En NPC kan vara en källa till: i guiden om NPC-dialog utlöser ett svar en handling på servern, och den handlingen kan på samma sätt anropa InventoryService.add.

Steg 6: utrusta Tool och använda föremål

Två RemoteEvent bär de enda förfrågningar som klienten kan göra. EquipItem lägger en kopia av föremålets Tool från ServerStorage i spelarens Backpack (hotbaren längst ner på skärmen) och i spelarens hand, och en ny förfrågan lägger undan den. UseItem tar bort ett exemplar av ett användbart föremål och tillämpar dess effekt, här är det helning.

Lägg in ett Script i ServerScriptService och döp det till InventoryActions:

Script i ServerScriptService med namnet 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 } = {}

-- Varje förfrågan börjar här. En klient kan skicka vad som helst när som helst, så
-- vi kontrollerar typen, att föremålet finns, att spelaren har det, och hur ofta.
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

-- Förstör föremålets Tool var kopian än finns: hotbar, hand 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 utrustat verktyg i taget

	local tool = template:Clone()
	tool.CanBeDropped = false -- en släppt kopia skulle kunna plockas upp av någon annan
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- En andra kopia i StarterGear kopieras tillbaka till Backpack efter en 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) -- direkt i handen
	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) -- ett nytt klick på det utrustade föremålet lägger undan det
	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 redan med full hälsa: förbruka inte föremålet
	end
	-- Ta först föremålet och hela bara om det gick
	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)
Vad varje förfrågan får göra
FörfråganKlienten skickarServern kontrollerar innan handlingen
EquipItemEtt föremåls-idDet är en sträng, föremålet finns, spelaren har det, förfrågningarna kommer inte oftare än fyra per sekund, föremålet har toolName, och ett Tool med det namnet ligger i ServerStorage.ItemTools
UseItemEtt föremåls-idSamma kontroller av typ, ägande och frekvens, föremålet har ett värde heal, karaktären lever och är skadad, och ett föremål tas bort innan hälsan läggs till

Tre detaljer hindrar ett Tool från att dupliceras eller försvinna. Kopian har CanBeDropped satt till false, eftersom ett släppt Tool faller ner i Workspace, där en annan spelare kan ta det, medan originalet ligger kvar i inventariet. Varje kopia bär attributet InventoryItem, så när föremålet läggs undan kan varje kopia hittas och förstöras var den än är. Och om spelaren har en StarterGear-behållare läggs en andra kopia i den. Roblox kopierar StarterGear till Backpack varje gång karaktären dyker upp, så ett utrustat svärd kommer tillbaka efter en respawn.

Bara ett Tool är utrustat i taget, och utrustningen sparas inte, så efter att ha gått in igen börjar spelaren med en tom hotbar. Om du senare lägger till försäljning eller att släppa föremål, lägg undan föremålet innan dess sista kopia lämnar inventariet.

Platshållarsvärdet kan du göra om till ett svärd som verkligen slåss: bygg ett Tool enligt guiden om svärd, behåll namnet Sword och lägg det i ItemTools i stället för platshållaren. Serverskriptet från den guiden kontrollerar varje slag, hur spelaren än fick svärdet.

Steg 7: rita inventariets rutnät

Ett LocalScript bygger hela fönstret i kod, så du behöver inte placera ut något för hand. En ScrollingFrame håller platserna, en UIGridLayout i den ordnar dem i rader, och AutomaticCanvasSize gör det skrollbara området större allteftersom rader läggs till.

Öppna StarterPlayer i Explorer, lägg in ett LocalScript i StarterPlayerScripts och döp det till InventoryClient:

LocalScript i StarterPlayerScripts med namnet 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. Bygg fönstret en gång. ResetOnSpawn = false behåller 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 den större så att rutorna får plats
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. En ruta per plats. Det här ritar bara det som servern skickade; själva
-- inventariet ändras aldrig härifrån.
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 plats
	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()
		-- Be, beordra inte: servern kontrollerar förfrågan och skickar tillbaka 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

-- Servern skickar det här efter laddningen och efter varje ändring
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Öppna och stäng med knappen eller tangenten 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)

Ett LocalScript i StarterPlayerScripts körs en gång per session, och ResetOnSpawn = false behåller ScreenGui när karaktären respawnar, så rutnätet fortsätter att visa den senaste kopian som servern skickade.

Klienten ritar en ruta för varje plats, även tomma, så ett inventarie med 20 platser ser alltid ut som 20 platser. Varje uppdatering förstör de gamla rutorna och bygger nya, vilket är enkelt och passar för några dussin platser. Om servern skickar InventoryUpdated innan det här skriptet har kopplat sig till det ställer Roblox meddelandet i kö och levererar det så fort hanteraren kopplas, så det första inventariet går inte förlorat.

Vill du rita fönstret i Studio? Bygg en ScreenGui med en mallplats och gör Clone på den i makeCell. För ikoner ger du föremålet en icon i katalogen med en bild som du har laddat upp, så visar dess ruta bilden i stället för namnet.

Testa inventariet

  1. Tryck på Play. Öppna inventariet med knappen till vänster eller tangenten B: en ny spelare har Sword och 3 Apple, och räknaren visar 2 / 20 slots. Så länge Studio inte kan nå datalager dyker föremålen upp efter några sekunder, efter varningar om laddningen i Output, och sparas inte.
  2. Klicka på Sword. Svärdet dyker upp i din hand och i hotbaren, och dess plats får en lila ram. Klicka igen för att lägga undan det.
  3. Gå fram till Apple-parten och använd dess prompt. Äppelstacken växer till 4, och parten försvinner i 15 sekunder.
  4. För att testa helningen sänker du först hälsan. Byt Client/Server till Server, markera din karaktärs Humanoid i Explorer, sätt Health till 50, byt tillbaka till Client och klicka på Apple.
  5. Med Studios åtkomst till API services påslagen stoppar du spelet och startar igen. Äpplet du plockade upp finns kvar. Om laddningen eller sparningen misslyckades säger Output det.

För att testa med flera spelare väljer du Server & Clients med 2 klienter i testinställningarna. Varje spelare ser bara sitt eget inventarie, och ett svärd i den andras hand ser båda.

Vanliga fel och lösningar

De flesta problem syns i fönstret Output som en varning eller en röd felrad. Läs den första: de följande felen kommer ofta av den.

Infinite yield possible på ett anrop till WaitForChild

Skriptet väntar på ett objekt som inte finns med exakt det namnet. Jämför din Explorer med trädet i steg 1: InventoryRemotes med tre RemoteEvent i ReplicatedStorage, ItemTools i ServerStorage och två moduler. Namnen skiljer på stora och små bokstäver. Guiden om skriptfel går igenom den här varningen mer ingående.

Rutnätet öppnas men förblir tomt

Klienten ritar bara det som servern skickar. Leta efter varningar Inventory load failed i Output och kontrollera att InventoryData är ett Script, inte ett LocalScript, i ServerScriptService, och att ModuleScript InventoryService ligger bredvid. Om Output visar felet Remote event invocation lyssnar ingen på InventoryUpdated på klienten: leta efter ett tidigare fel från InventoryClient.

Föremålen återställs varje gång jag spelar i Studio

Om Output skriver Inventory not loaded: playing with starter items that will not be saved är din place inte publicerad, eller så är Studios åtkomst till API services avstängd. Slå på den som i steg 4, i en testkopia av ditt spel.

Ett klick på svärdet gör ingenting

Leta efter Cannot equip sword i Output: Tool i ServerStorage.ItemTools måste heta exakt som toolName i katalogen. Ett Tool behöver också en part med namnet Handle för att kunna hållas, om du inte har satt dess RequiresHandle till false.

Upplockningsprompten dyker upp, men inget läggs till

Attributet ItemId måste stämma exakt med id:t i katalogen, även stora och små bokstäver: apple, inte Apple. Inget läggs till medan spelarens inventarie fortfarande laddas eller när det inte finns plats för hela antalet.

Sparandet går sönder efter att jag ändrat vad som sparas

Datalager tar emot enkel data: strängar, tal, booleska värden och tabeller av dem. Att spara ett Tool, en Part eller någon annan Instance misslyckas, eller så sparas värdet som nil. Spara föremålets id och antal, och återskapa allt annat från katalogen, som serialize gör.

Gör det med RoCode

Om det är enklare för dig att beskriva systemet än att bygga det för hand kan RoCode bygga det i din öppna place. Det är en AI-agent för Roblox Studio: du beskriver funktionen i webbchatten, och dess Studio-plugin skapar skript och objekt i din Explorer i stället för att ge dig kod att klistra in.

Du skriver

Lägg till ett inventarie med 20 platser med stackar av föremål, ett UI-rutnät som öppnas med B, ett svärd från ServerStorage som spelarna kan utrusta, äpplen som helar och sparande med DataStoreService.

RoCode gör
  • Kan gå igenom din place när ett steg kräver det, med Search Game och Search Scripts, för att bygga vidare på föremål, remotes eller sparkod som redan finns i stället för att lägga till ett andra system
  • Skapar mappar och RemoteEvent med Create Instance, och ModuleScript, Script och LocalScript med Create Script
  • Kan bygga ett fönsterutkast med Build UI, som har en inventarielayout med platshållarplatser; koden som fyller platserna från servern skrivs i separata skript
  • Kontrollerar att varje skript kompilerar i Studio med Check Script, som fångar kompileringsfel och några riskabla mönster, men inte kontrollerar typer, inte gör lint och inte kör din kod

Varje omgång ändringar är en ångrapunkt i Studio. RoCode kan inte slå på Studios åtkomst till API services, det gör du själv. Med plugin 3.9 eller senare kan den köra ett kort speltest och läsa felen, och med plugin 3.9.15 eller senare kan dess testkaraktär trycka på tangenter och utrusta föremål, men den kontrollerar bara det som den själv har bestämt sig för att testa, så testa sparandet själv i ett speltest. Ett inventarie ligger ovanpå andra system, som sparande och verktyg, och AI-spelbyggaren som bygger i din egen place i Studio lägger till dem en prompt i taget. Så ansluter RoCode till Studio.

Vanliga frågor

Ska jag använda Backpack i Roblox i stället för ett eget inventarie?

Backpack är Roblox inbyggda inventarie: varje Tool i den visas som en knapp i hotbaren. Om alla föremål i ditt spel är Tool och du inte behöver stackar, antal och en gräns för platser kan det räcka, även om du ändå måste spara vilka Tool varje spelare har. Ett eget inventarie behövs för föremål som inte är Tool, till exempel material och förbrukningsvaror. Den här guiden använder båda: inventariet håller allt, och Backpack håller det utrustade Tool.

Hur döljer jag standard-hotbaren i Roblox?

Anropa StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) från ett LocalScript. När hotbaren är dold behöver spelarna ett annat sätt att ta fram och lägga undan det utrustade Tool, till exempel en knapp som ber servern anropa Humanoid:EquipTool eller Humanoid:UnequipTools.

Hur får jag platser att behålla sin position för drag and drop?

Spara en lista med fast längd med en post per plats och markera tomma platser med ett värde som ett tomt id, inte nil, eftersom Roblox avråder från att skicka tabeller med nil via RemoteEvent. Lägg sedan till ett RemoteEvent MoveItem som skickar två platsnummer, och låt servern kontrollera att båda är heltal från 1 till kapaciteten innan de byter plats.

Hur stort kan ett sparat inventarie vara?

Ett värde i ett datalager kan ta upp till 4 194 304 tecken efter serialisering (enligt dokumentationen den 30 september 2026). En lista med id och antal tar en pytteliten del av det. Det som får sparningen att växa är text per föremål, till exempel egna namn eller långa beskrivningar som sparas för varje föremål.

Hur köper och säljer jag föremål för mynt?

Gör allt på servern. För att sälja anropar du InventoryService.remove och betalar bara om den returnerade true. För att köpa kontrollerar du priset och spaceFor, tar mynten och anropar sedan add. Guiden om butiker bygger köpsidan.

Källor och vidare läsning

Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.