Guide · Spillsystemer

Hvordan lage et inventar i Roblox Studio

Et inventar virker som en oppgave om grensesnitt, men om det kan hackes og om det mister gjenstander, avgjøres av hvor gjenstandene lagres. I denne guiden ligger hver spillers gjenstander i en tabell på serveren, hver spiller får en kopi og tegner den som et rutenett, utstyrer Tool og bruker forbruksvarer via forespørsler som serveren sjekker, og alt lagres i en datastore.

Oppdatert 20. november 202616 min lesingSkrevet av

Kort fortalt

Lagre hver spillers gjenstander i en tabell på serveren, inne i et ModuleScript i ServerScriptService, og la bare den koden legge til, fjerne og stable dem. Beskriv gjenstandene én gang i et ModuleScript i ReplicatedStorage (id, navn, maks stack). Etter hver endring sender serveren denne spilleren en RemoteEvent med en kopi av inventaret, og et LocalScript tegner det som et rutenett med ScrollingFrame og UIGridLayout.

  • Klienten legger aldri til gjenstander. Den kan bare be om noe, for eksempel "utstyr sverdet mitt", og serveren sjekker at spilleren har det før den gjør noe.
  • Gjenstander dukker bare opp via serverkode du styrer: plukking, kjøp i butikken etter sjekk på serveren, belønninger.
  • Lagre gjenstandenes id og antall, ikke Tool, med DataStoreService når spilleren går ut, når serveren slås av og hvert par minutter. Lagre aldri en spiller hvis data ikke ble lastet.
På denne siden
  1. Slik er det bygd opp
  2. Hvorfor gjenstandene er på serveren
  3. 1. Gjør klar Explorer
  4. 2. Gjenstandskatalog
  5. 3. Inventar på serveren
  6. 4. Lasting og lagring
  7. 5. Plukke opp gjenstander
  8. 6. Utstyring og bruk
  9. 7. Rutenett i UI
  10. Testing
  11. Common errors
  12. Med RoCode
  13. Ofte stilte spørsmål
  14. Kilder og videre lesing

Slik er inventaret bygd opp

IllustrasjonTrykk B, hold musepekeren over en gjenstand for å lese beskrivelsen, klikk på Sword for å ta det i hånden.

Systemet består av seks små deler, og hver har én oppgave. Alle reglene for gjenstander bor i én servermodul, så når noe går i stykker, er det nøyaktig ett sted å lete.

Delene i systemet og hvor de kjører
DelType og plasseringOppgave
ItemCatalogModuleScript i ReplicatedStorageHva hver gjenstand er: navn, beskrivelse, maks stack og om den kan utstyres eller brukes. Serveren og alle klientene leser den.
InventoryServiceModuleScript i ServerScriptServiceHolder alle spillernes slots. Den eneste koden som legger til, fjerner og stabler gjenstander.
InventoryDataScript i ServerScriptServiceLaster spillerens gjenstander ved innlogging og lagrer dem.
InventoryActionsScript i ServerScriptServiceSjekker og utfører forespørsler om utstyring og bruk.
ItemPickupScript inne i en PartGir gjenstanden til den som plukket den opp.
InventoryClientLocalScript i StarterPlayerScriptsTegner rutenettet og sender forespørsler. Endrer ingenting selv.

Dataene går én vei. Serveren endrer inventaret, sender så InventoryUpdated med hele inventaret til denne spilleren, og klienten tegner det på nytt. Når spilleren klikker på en slot, sender klienten EquipItem eller UseItem med gjenstandens id; serveren sjekker forespørselen, gjør endringen, og en ny kopi kommer samme vei. Å sende hele inventaret er enklere enn å sende endringer, og for noen titalls slots er meldingen fortsatt liten.

Hvorfor klienten aldri legger til gjenstander

Det er fristende å legge til en gjenstand rett i LocalScript-et som viser den: spilleren klikket, sloten ble fylt. Det går galt på to måter.

  • Ingen andre ser det. En endring i et LocalScript finnes bare på den spillerens enhet. Serveren får ikke vite om den, så den lagres ikke, og ingen serverskript kan bruke den.
  • Hvem som helst kan forfalske det. Hvis du fikser det med en remote som AddItem(itemId, amount), kan en juksemaker kalle den hendelsen selv, med hvilke argumenter som helst og så mange ganger hen vil. Roblox sin sikkerhetsguide sier at serveren må sjekke alt klienten sender før det brukes.

Derfor kan klienten i denne guiden bare be om å gjøre noe med gjenstander spilleren allerede har: "utstyr dette" og "bruk dette". Hver forespørsel har én gjenstands-id og ingen antall, og på serveren går den gjennom én sjekk: det er en streng, gjenstanden finnes, spilleren har minst én, og spilleren sender ikke mer enn fire forespørsler i sekundet. Deretter finner serveren selv Tool via katalogen. Den tar aldri imot et Tool, en sti eller en instans fra klienten, noe den samme guiden advarer mot.

Gjenstander havner bare i inventaret via serverkode: en plukking som serveren har sjekket, et kjøp serveren har trukket penger for (det bygges i butikkguiden), en belønning for et oppdrag eller en drop. Om remotes generelt, med sjekk av andre typer argumenter, kan du lese i RemoteEvent-guiden.

Steg 1: gjør klar Explorer

Lag disse objektene for hånd. Skriptene i de neste stegene finner dem etter navn, så skriv hvert navn nøyaktig som her.

  1. I ReplicatedStorage setter du inn en Folder med navnet InventoryRemotes. Inni den setter du inn tre RemoteEvent med navnene InventoryUpdated, EquipItem og UseItem.
  2. I ServerStorage setter du inn en Folder med navnet ItemTools. Inni den setter du inn et Tool med navnet Sword, og i Tool en Part med navnet Handle (1 ganger 4 ganger 1 stud holder fint). Sjekk at Anchored ikke er huket av på Handle: Roblox advarer om at karakteren blir sittende fast hvis den holder et verktøy med ankrede parts. Et Tool du allerede har, går også, så lenge navnet stemmer med katalogen fra steg 2.
  3. Legg til skriptene etter hvert som du går gjennom stegene. Treet viser hvor hvert av dem skal.
Explorer når guiden er ferdig
ReplicatedStorage
  ItemCatalog ModuleScript new
  InventoryRemotes Folder new
    InventoryUpdated RemoteEvent new
    EquipItem RemoteEvent new
    UseItem RemoteEvent new
ServerScriptService
  InventoryService ModuleScript new
  InventoryData Script new
  InventoryActions Script new
ServerStorage
  ItemTools Folder new
    Sword Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    InventoryClient LocalScript new
Workspace
  Apple Part new
    ItemPickup Script new

Steg 2: beskriv gjenstandene i katalogen

Katalogen beskriver hver gjenstand som kan finnes, én gang. Inventarene lagrer deretter bare gjenstandens id og antall. Slik holdes lagringene små, og senere kan du gi en gjenstand nytt navn eller skrive om beskrivelsen uten å røre noens lagrede data.

Sett inn et ModuleScript i ReplicatedStorage, kall det ItemCatalog og erstatt innholdet med dette:

ModuleScript i ReplicatedStorage med navnet ItemCatalog
-- Alle gjenstandene som kan finnes i spillet. Denne listen leses av serveren og alle
-- klientene; bare serveren bestemmer hvem som har hva.
export type Item = {
	id: string, -- må være det samme som nøkkelen under
	name: string,
	description: string,
	maxStack: number, -- hvor mange av denne gjenstanden som får plass i én slot
	icon: string?, -- valgfritt bilde: "rbxassetid://" pluss ID-en til bildet ditt
	toolName: string?, -- Tool i ServerStorage.ItemTools: gjenstanden kan utstyres
	heal: number?, -- hvor mye helse den gir tilbake: gjenstanden er en forbruksvare
}

local items: { [string]: Item } = {
	sword = {
		id = "sword",
		name = "Sword",
		description = "Equip it to put it in your hand.",
		maxStack = 1,
		toolName = "Sword",
	},
	apple = {
		id = "apple",
		name = "Apple",
		description = "Use it to restore 25 health.",
		maxStack = 10,
		heal = 25,
	},
	wood = {
		id = "wood",
		name = "Wood",
		description = "A building material.",
		maxStack = 50,
	},
}

local ItemCatalog = {}

-- Gir tilbake gjenstanden med denne id-en, eller nil hvis det ikke finnes en slik gjenstand
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

De valgfrie feltene bestemmer hva en gjenstand gjør. toolName gjør at den kan utstyres, heal gjør at den kan brukes, og en gjenstand uten noen av feltene, som tre, ligger i inventaret til annen serverkode fjerner den (crafting, salg).

For å legge til en gjenstand legger du til en oppføring der nøkkelen og id er like. Id-er skiller mellom store og små bokstaver, og det er de som lagres, så endre aldri en id når spillere allerede har gjenstanden: endre name i stedet.

Steg 3: lagre inventarene på serveren

Dette ModuleScript-et eier inventaret til hver spiller. Hvert inventar er en liste over slots, der hver slot har en gjenstands-id og et antall, pluss en kapasitet på 20 slots. Andre serverskript kaller funksjonene i det, og ingen andre redigerer tabellen.

Sett inn et ModuleScript i ServerScriptService og kall det InventoryService:

ModuleScript i ServerScriptService med navnet InventoryService
-- Den eneste koden som endrer inventarer. Den ligger i ServerScriptService,
-- der klientene verken kan se eller kjøre den.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Strict-modus ser ikke hva require via WaitForChild gir tilbake, så vi
-- beskriver den delen av modulen som dette skriptet bruker
type Item = { id: string, maxStack: number }
type Catalog = { get: (id: string) -> Item? }
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog

local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent

export type Slot = { id: string, count: number }
type Inventory = { slots: { Slot }, capacity: number, equipped: string? }

local CAPACITY = 20 -- slots per spiller
local STARTER_ITEMS: { Slot } = { -- det en helt ny spiller starter med
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Sender eieren en kopi av inventaret. Kalles etter hver endring.
local function sync(player: Player)
	local inventory = inventories[player]
	if inventory then
		inventoryUpdated:FireClient(player, {
			capacity = inventory.capacity,
			slots = inventory.slots,
			equipped = inventory.equipped,
		})
	end
end

-- Stackregler: fyll først opp stacks som ikke er fulle, start så nye stacks
-- i tomme slots. Gir tilbake hvor mange som ble lagt til, det kan være færre enn ønsket.
local function addToInventory(inventory: Inventory, item: Item, amount: number): number
	local remaining = amount
	for _, slot in inventory.slots do
		if remaining == 0 then
			break
		end
		if slot.id == item.id and slot.count < item.maxStack then
			local moved = math.min(item.maxStack - slot.count, remaining)
			slot.count += moved
			remaining -= moved
		end
	end
	while remaining > 0 and #inventory.slots < inventory.capacity do
		local moved = math.min(item.maxStack, remaining)
		table.insert(inventory.slots, { id = item.id, count = moved })
		remaining -= moved
	end
	return amount - remaining
end

function InventoryService.count(player: Player, itemId: string): number
	local inventory = inventories[player]
	local total = 0
	if inventory then
		for _, slot in inventory.slots do
			if slot.id == itemId then
				total += slot.count
			end
		end
	end
	return total
end

-- Hvor mye mer av gjenstanden som får plass: plass i stackene pluss tomme slots
function InventoryService.spaceFor(player: Player, itemId: string): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	if not inventory or not item then
		return 0
	end
	local space = (inventory.capacity - #inventory.slots) * item.maxStack
	for _, slot in inventory.slots do
		if slot.id == itemId then
			space += item.maxStack - slot.count
		end
	end
	return space
end

-- Legger til opptil amount stykker av gjenstanden. Gir tilbake hvor mange som ble lagt til (0 hvis
-- gjenstanden ikke finnes, inventaret er fullt eller ikke er lastet ennå).
function InventoryService.add(player: Player, itemId: string, amount: number): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	local wanted = math.floor(amount)
	if not inventory or not item or wanted < 1 then
		return 0
	end
	local added = addToInventory(inventory, item, wanted)
	if added > 0 then
		sync(player)
	end
	return added
end

-- Fjerner nøyaktig amount stykker av gjenstanden, fra de siste stackene.
-- Hvis spilleren har færre, fjernes ingenting, og false gis tilbake.
function InventoryService.remove(player: Player, itemId: string, amount: number): boolean
	local inventory = inventories[player]
	local wanted = math.floor(amount)
	if not inventory or wanted < 1 or InventoryService.count(player, itemId) < wanted then
		return false
	end
	local remaining = wanted
	-- Vi går bakfra, så table.remove ikke hopper over slots
	for index = #inventory.slots, 1, -1 do
		local slot = inventory.slots[index]
		if slot.id == itemId then
			local taken = math.min(slot.count, remaining)
			slot.count -= taken
			remaining -= taken
			if slot.count == 0 then
				table.remove(inventory.slots, index)
			end
			if remaining == 0 then
				break
			end
		end
	end
	sync(player)
	return true
end

function InventoryService.getEquipped(player: Player): string?
	local inventory = inventories[player]
	return if inventory then inventory.equipped else nil
end

function InventoryService.setEquipped(player: Player, itemId: string?)
	local inventory = inventories[player]
	if inventory then
		inventory.equipped = itemId
		sync(player)
	end
end

-- Kalles når spillerens lagrede data er lastet. saved er det
-- datastoren ga tilbake: nil for en ny spiller. Hver oppføring går på nytt gjennom
-- stackreglene, så slettede gjenstander og gamle stackstørrelser ødelegger ingenting.
function InventoryService.load(player: Player, saved: any)
	local inventory: Inventory = { slots = {}, capacity = CAPACITY }
	local entries: { Slot } = STARTER_ITEMS
	if type(saved) == "table" and type(saved.slots) == "table" then
		entries = {}
		for _, entry in saved.slots do
			if type(entry) == "table" and type(entry.id) == "string" and type(entry.count) == "number" then
				table.insert(entries, { id = entry.id, count = math.floor(entry.count) })
			end
		end
	end
	for _, entry in entries do
		local item = ItemCatalog.get(entry.id)
		if item and entry.count > 0 then
			addToInventory(inventory, item, entry.count)
		end
	end
	inventories[player] = inventory
	sync(player)
end

-- En enkel kopi for lagring, eller nil hvis spillerens data aldri ble lastet
function InventoryService.serialize(player: Player): { version: number, slots: { Slot } }?
	local inventory = inventories[player]
	if not inventory then
		return nil
	end
	local slots: { Slot } = {}
	for index, slot in inventory.slots do
		slots[index] = { id = slot.id, count = slot.count }
	end
	return { version = 1, slots = slots }
end

function InventoryService.unload(player: Player)
	inventories[player] = nil
end

return InventoryService

Linjene med type og typekonverteringen :: etter require trengs bare av Luau sin typesjekker, som ikke ser hva en modul funnet med WaitForChild gir tilbake. Mens spillet kjører, endrer de ingenting. De andre skriptene i denne guiden gjør det samme.

Slik virker stackreglene med katalogen over, der epler stables opp til 10:

  • Legger du til 15 epler hos en spiller med en stack på 7, fylles den stacken opp til 10, og så starter en ny stack på 5.
  • Når det er tomt for slots, legger add til det som fikk plass og gir tilbake det tallet. Kall spaceFor først når du trenger alt eller ingenting, slik plukkingen i steg 5 gjør.
  • remove virker etter prinsippet alt eller ingenting. En forespørsel om 3 epler hos en spiller som har 2, fjerner ingenting og gir tilbake false, så sjekk resultatet før du gir noe tilbake.
  • Det er ingen hull i slotsene: når en slot blir tom, flytter resten seg opp. Slik er listen enklere å sende og lagre. Slots som holder plassen sin, er omtalt i spørsmålene på slutten.
Hva andre serverskript kan kalle
FunksjonGir tilbakeBrukes til
add(player, itemId, amount)Hvor mange som ble lagt tilPlukking, belønninger, kjøp
remove(player, itemId, amount)true hvis alt ble fjernetBruk, salg, crafting
count(player, itemId)Summen over alle stacksSjekke hva spilleren har
spaceFor(player, itemId)Hvor mye mer som får plassSjekk før tillegg etter prinsippet alt eller ingenting
getEquipped, setEquippedId-en til den utstyrte gjenstanden eller nilUtstyring, i steg 6
load, serialize, unloadEn kopi klar til lagring (serialize)Lasting og lagring, i steg 4

Steg 4: last og lagre hvert inventar

Inventarene bor i serverens minne, så de forsvinner når spilleren går ut. Dette skriptet laster spillerens slots fra en datastore når spilleren kommer inn, og skriver dem tilbake når spilleren går ut, når serveren slås av og hvert tredje minutt i tilfelle serveren krasjer. Det lagrer bare gjenstandenes id og antall: datastores kan ikke lagre en Instance, for eksempel et Tool.

Sett inn et Script i ServerScriptService og kall det InventoryData:

Script i ServerScriptService med navnet InventoryData
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")
local ServerScriptService = game:GetService("ServerScriptService")

type InventoryApi = {
	load: (player: Player, saved: any) -> (),
	serialize: (player: Player) -> any,
	unload: (player: Player) -> (),
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local STORE_NAME = "PlayerInventory_v1"
local LOAD_ATTEMPTS = 3
local AUTOSAVE_SECONDS = 180

-- Bare spillere hvis data ble lastet, lagres. Etter en mislykket lasting
-- må vi ikke lagre, ellers erstatter et tomt inventar det ekte.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Én mislykket forespørsel skal ikke koste noen gjenstander, så vi prøver flere ganger.
-- GetDataStore er også inne i pcall, så en Studio-økt uten tilgang til
-- datastores får en advarsel i stedet for å stoppe dette skriptet.
local function loadSaved(player: Player): (boolean, any)
	for attempt = 1, LOAD_ATTEMPTS do
		local ok, result = pcall(function()
			return DataStoreService:GetDataStore(STORE_NAME):GetAsync(keyFor(player))
		end)
		if ok then
			return true, result
		end
		warn(`Inventory load failed for {player.Name} (attempt {attempt}): {result}`)
		if attempt < LOAD_ATTEMPTS then
			task.wait(attempt * 2)
		end
	end
	return false, nil
end

local function onPlayerAdded(player: Player)
	local ok, saved = loadSaved(player)
	if player.Parent ~= Players then
		return -- spilleren gikk ut mens vi lastet
	end
	if ok then
		InventoryService.load(player, saved) -- saved er nil for en ny spiller
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Betyr vanligvis at Studio sin tilgang til API services er slått av. Vi spiller med
		-- startgjenstandene så du kan teste, men lagrer dem aldri.
		warn("Inventory not loaded: playing with starter items that will not be saved")
		InventoryService.load(player, nil)
	else
		player:Kick("Your inventory could not be loaded. Please rejoin in a minute.")
	end
end

local function save(player: Player)
	if not canSave[player] then
		return -- dataene ble aldri lastet, det er ingenting som trygt kan skrives
	end
	local data = InventoryService.serialize(player)
	if not data then
		return
	end
	activeSaves += 1
	local ok, err = pcall(function()
		DataStoreService:GetDataStore(STORE_NAME):SetAsync(keyFor(player), data, { player.UserId })
	end)
	activeSaves -= 1
	if not ok then
		warn(`Inventory save failed for {player.Name}: {err}`)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
	task.spawn(onPlayerAdded, player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	save(player)
	canSave[player] = nil
	InventoryService.unload(player)
end)

-- Når serveren slås av, lagrer vi alle som fortsatt er her, og venter på hver
-- pågående lagring, også dem PlayerRemoving startet
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Vi lagrer alle hvert par minutter, så et serverkrasj koster minutter, ikke hele økten
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Hva skriptet gjør og hvorfor:

  • Lasting med standardverdier. En ny spiller har ingen lagret verdi, så GetAsync gir tilbake nil, og spilleren får startgjenstandene. Lagrede slots går på nytt gjennom stackreglene, så en gjenstand som er fjernet fra katalogen, eller en mindre maks stack, ødelegger ikke lastingen. Alt som ikke lenger får plass, eller hvis id ikke lenger finnes i katalogen, kastes, og neste lagring gjør det permanent, så behold hver id spillere kan ha i katalogen.
  • Aldri lagre etter en mislykket lasting. Bare spillere i canSave skrives. På en levende server blir en spiller hvis data ikke ble lastet selv etter tre forsøk, bedt om å bli med på nytt. I Studio får spilleren i stedet startgjenstander som ikke lagres, noen sekunder senere på grunn av de nye forsøkene. Slik blir det til placen er publisert med API-tilgang slått på.
  • Lagring ved utlogging og ved avslutning. BindToClose lagrer alle som fortsatt er på serveren, og venter på lagringer som allerede pågår. Roblox gir bundne funksjoner opptil 30 sekunder.
  • Hold deg innenfor grensene. Én skriving per spiller hvert tredje minutt pluss én ved utlogging er langt under standardbudsjettet til en server på 60 skrivinger i minuttet pluss 40 per spiller (ifølge dokumentasjonen per 30. september 2026). Nøkkelmønsteret User_ er hentet fra Roblox sine anbefalinger, og å sende user ID til SetAsync knytter dataene til den spilleren, noe Roblox sterkt anbefaler for å håndtere forespørsler om sletting av data.

For et lite spill er dette et solid grunnlag. Sesjonslåsing, som hindrer at en spiller som raskt bytter server, laster dataene før den gamle serveren har lagret dem, og når du skal bruke UpdateAsync i stedet for SetAsync, er gjennomgått i DataStore-guiden.

Steg 5: del ut gjenstander fra verdenen

Plukking er den enkleste måten gjenstander havner i inventaret på: en part med en ProximityPrompt som legger til gjenstanden når spilleren bruker den. Skriptet lytter på Triggered-hendelsen på serveren, så gjenstanden legges til der klienten ikke kan blande seg inn.

  1. Legg til en Part i Workspace, kall den Apple og farg den rød. Slå på Anchored og slå av CanCollide, så ingen krasjer i den mens den er usynlig. Prompten viser navnet på parten.
  2. Med parten merket ruller du Properties-vinduet ned til Attributes og klikker +. Legg til ItemId av typen string og klikk Save, og sett så verdien til apple. Legg på samme måte til Amount av typen number med verdien 1.
  3. Sett inn et Script i parten, kall det ItemPickup og lim inn denne koden:
Script i Apple-parten i Workspace med navnet ItemPickup
-- Legg dette Script inne i en Part og gi Part to attributter:
-- ItemId (streng, for eksempel apple) og Amount (tall, for eksempel 1).
local ServerScriptService = game:GetService("ServerScriptService")

type InventoryApi = {
	add: (player: Player, itemId: string, amount: number) -> number,
	spaceFor: (player: Player, itemId: string) -> number,
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local part = script.Parent :: BasePart
local RESPAWN_SECONDS = 15

local itemId = part:GetAttribute("ItemId")
local amount = part:GetAttribute("Amount")
if typeof(itemId) ~= "string" or typeof(amount) ~= "number" or amount < 1 then
	error(`{part:GetFullName()} needs an ItemId (string) and an Amount (number, 1 or more) attribute`)
end

local prompt = Instance.new("ProximityPrompt")
prompt.ActionText = "Pick up"
prompt.ObjectText = part.Name
prompt.Parent = part

local visibleTransparency = part.Transparency

prompt.Triggered:Connect(function(player: Player)
	if not prompt.Enabled then
		return -- noen andre plukket den opp akkurat nå
	end
	-- Vi sjekker avstanden på serveren i stedet for å stole på forespørselen
	local character = player.Character
	if not character then
		return
	end
	local distance = (character:GetPivot().Position - part.Position).Magnitude
	if distance > prompt.MaxActivationDistance + 5 then
		return
	end
	if InventoryService.spaceFor(player, itemId) < amount then
		return -- ikke nok plass: vi lar gjenstanden ligge
	end
	InventoryService.add(player, itemId, amount)

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

Kopier parten for å plassere ut flere gjenstander. Endre attributtene for å dele ut tre, et sverd til eller en stack med epler.

Roblox sjekker avstanden for Triggered, men sikkerhetsguiden sier likevel at du skal sjekke prompter på serveren: en juksemaker kan utløse prompthendelser selv når Enabled er false, og kan trekke en part som ikke er ankret, til karakteren sin. Derfor sjekker skriptet selv Enabled og avstanden, og derfor er parten ankret.

Alle andre serverskript deler ut gjenstander på samme måte. Etter et kjøp, et oppdrag eller et drap henter du InventoryService med require, slik skriptene over gjør, og kaller InventoryService.add(player, "wood", 5). Sjekk spaceFor først når gjenstanden ikke må gå tapt. En NPC kan også være en kilde: i guiden om NPC-dialog starter et svar en handling på serveren, og den handlingen kan på samme måte kalle InventoryService.add.

Steg 6: utstyr Tool og bruk gjenstander

To RemoteEvent bærer de eneste forespørslene klienten kan gjøre. EquipItem legger en kopi av gjenstandens Tool fra ServerStorage i spillerens Backpack (hotbaren nederst på skjermen) og i hånden, og en ny forespørsel fjerner den. UseItem fjerner ett stykke av en gjenstand som kan brukes, og gir effekten, her helbredelse.

Sett inn et Script i ServerScriptService og kall det InventoryActions:

Script i ServerScriptService med navnet InventoryActions
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
local ServerStorage = game:GetService("ServerStorage")

type Item = { id: string, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type InventoryApi = {
	count: (player: Player, itemId: string) -> number,
	remove: (player: Player, itemId: string, amount: number) -> boolean,
	getEquipped: (player: Player) -> string?,
	setEquipped: (player: Player, itemId: string?) -> (),
}
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent
local itemTools = ServerStorage:WaitForChild("ItemTools")

local COOLDOWN_SECONDS = 0.25
local lastRequest: { [Player]: number } = {}

-- Hver forespørsel starter her. Klienten kan sende hva som helst når som helst, så
-- vi sjekker typen, at gjenstanden finnes, at spilleren har den, og hvor ofte.
local function ownedItem(player: Player, itemId: unknown): Item?
	if typeof(itemId) ~= "string" then
		return nil
	end
	local now = os.clock()
	if now - (lastRequest[player] or 0) < COOLDOWN_SECONDS then
		return nil
	end
	lastRequest[player] = now
	local item = ItemCatalog.get(itemId)
	if not item or InventoryService.count(player, itemId) < 1 then
		return nil
	end
	return item
end

-- Ødelegger Tool for denne gjenstanden uansett hvor kopien er: hotbar, hånd eller StarterGear
local function destroyTools(container: Instance?, itemId: string)
	if not container then
		return
	end
	for _, child in container:GetChildren() do
		if child:IsA("Tool") and child:GetAttribute("InventoryItem") == itemId then
			child:Destroy()
		end
	end
end

local function unequip(player: Player)
	local equippedId = InventoryService.getEquipped(player)
	if equippedId then
		destroyTools(player:FindFirstChildOfClass("Backpack"), equippedId)
		destroyTools(player.Character, equippedId)
		destroyTools(player:FindFirstChildOfClass("StarterGear"), equippedId)
		InventoryService.setEquipped(player, nil)
	end
end

local function equip(player: Player, item: Item, toolName: string)
	local template = itemTools:FindFirstChild(toolName)
	local backpack = player:FindFirstChildOfClass("Backpack")
	if not template or not template:IsA("Tool") or not backpack then
		warn(`Cannot equip {item.id}: no Tool named {toolName} in ServerStorage.ItemTools`)
		return
	end
	unequip(player) -- ett utstyrt verktøy om gangen

	local tool = template:Clone()
	tool.CanBeDropped = false -- en sluppet kopi kunne blitt plukket opp av noen andre
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- En kopi nummer to i StarterGear kopieres tilbake til Backpack etter respawn
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		local gearCopy = tool:Clone()
		gearCopy.Parent = starterGear
	end

	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid and humanoid.Health > 0 then
		humanoid:EquipTool(tool) -- rett i hånden
	end
	InventoryService.setEquipped(player, item.id)
end

equipItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.toolName then
		return
	end
	if InventoryService.getEquipped(player) == item.id then
		unequip(player) -- et nytt klikk på den utstyrte gjenstanden legger den bort
	else
		equip(player, item, item.toolName)
	end
end)

useItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.heal then
		return
	end
	local heal = item.heal
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or humanoid.Health >= humanoid.MaxHealth then
		return -- død eller allerede på full helse: vi bruker ikke opp gjenstanden
	end
	-- Først tar vi gjenstanden, og vi helbreder bare hvis det gikk
	if InventoryService.remove(player, item.id, 1) then
		humanoid.Health = math.min(humanoid.MaxHealth, humanoid.Health + heal)
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)
Hva hver forespørsel har lov til
ForespørselKlienten senderServeren sjekker før handlingen
EquipItemGjenstandens idDet er en streng, gjenstanden finnes, spilleren har den, forespørslene kommer ikke oftere enn fire i sekundet, gjenstanden har toolName, og et Tool med det navnet ligger i ServerStorage.ItemTools
UseItemGjenstandens idDe samme sjekkene av type, eierskap og frekvens, gjenstanden har en heal-verdi, karakteren lever og er skadet, og én gjenstand er fjernet før helse legges til

Tre detaljer hindrer at et Tool blir doblet eller går tapt. Kopien har CanBeDropped satt til false, fordi et sluppet Tool faller ned i Workspace, der en annen spiller kan ta det, mens originalen fortsatt er i inventaret. Hver kopi har attributtet InventoryItem, så når gjenstanden legges bort, kan hver kopi finnes og ødelegges, uansett hvor den er. Og hvis spilleren har en StarterGear-beholder, legges en kopi nummer to i den. Roblox kopierer StarterGear til Backpack hver gang karakteren dukker opp, så et utstyrt sverd kommer tilbake etter respawn.

Bare ett Tool er utstyrt om gangen, og utstyringen lagres ikke, så etter å ha blitt med på nytt starter spilleren med en tom hotbar. Hvis du senere legger til salg eller å kaste gjenstander, legg bort gjenstanden før den siste kopien forlater inventaret.

Plassholdersverdet kan gjøres om til et sverd som faktisk slåss: bygg et Tool etter sverdguiden, behold navnet Sword og legg det i ItemTools i stedet for plassholderen. Serverskriptet fra den guiden sjekker hvert slag, uansett hvordan spilleren fikk sverdet.

Steg 7: tegn inventarrutenettet

LocalScript-et bygger hele vinduet i kode, så du trenger ikke plassere noe for hånd. ScrollingFrame holder slotsene, UIGridLayout inni den legger dem ut i rader, og AutomaticCanvasSize gjør det rullbare området større etter hvert som rader legges til.

I Explorer åpner du StarterPlayer, setter inn et LocalScript i StarterPlayerScripts og kaller det InventoryClient:

LocalScript i StarterPlayerScripts med navnet InventoryClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")

type Item = { name: string, description: string, icon: string?, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type Slot = { id: string, count: number }
type Snapshot = { capacity: number, slots: { Slot }, equipped: string? }

local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent

local player = Players.LocalPlayer
local TOGGLE_KEY = Enum.KeyCode.B

local COLOURS = {
	panel = Color3.fromRGB(24, 20, 36),
	slot = Color3.fromRGB(44, 38, 64),
	empty = Color3.fromRGB(34, 30, 48),
	equipped = Color3.fromRGB(124, 77, 255),
	text = Color3.fromRGB(240, 238, 245),
	muted = Color3.fromRGB(170, 165, 185),
}

local function addCorner(parent: GuiObject, radius: number)
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, radius)
	corner.Parent = parent
end

local function makeLabel(parent: GuiObject, text: string, textSize: number): TextLabel
	local label = Instance.new("TextLabel")
	label.BackgroundTransparency = 1
	label.Font = Enum.Font.BuilderSansBold
	label.TextColor3 = COLOURS.text
	label.TextSize = textSize
	label.Text = text
	label.Parent = parent
	return label
end

-- 1. Vi bygger vinduet én gang. ResetOnSpawn = false beholder det etter respawn.
local gui = Instance.new("ScreenGui")
gui.Name = "InventoryGui"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

local openButton = Instance.new("TextButton")
openButton.AnchorPoint = Vector2.new(0, 0.5)
openButton.Position = UDim2.new(0, 16, 0.5, 0)
openButton.Size = UDim2.fromOffset(140, 40)
openButton.BackgroundColor3 = COLOURS.panel
openButton.Font = Enum.Font.BuilderSansBold
openButton.TextColor3 = COLOURS.text
openButton.TextSize = 18
openButton.Text = "Inventory (B)"
addCorner(openButton, 8)
openButton.Parent = gui

local panel = Instance.new("Frame")
panel.AnchorPoint = Vector2.new(0.5, 0.5)
panel.Position = UDim2.fromScale(0.5, 0.5)
panel.Size = UDim2.fromScale(0.9, 0.8)
panel.BackgroundColor3 = COLOURS.panel
panel.Visible = false
addCorner(panel, 12)
panel.Parent = gui

local sizeLimit = Instance.new("UISizeConstraint")
sizeLimit.MaxSize = Vector2.new(440, 400)
sizeLimit.Parent = panel

local title = makeLabel(panel, "Inventory", 22)
title.Position = UDim2.fromOffset(16, 8)
title.Size = UDim2.new(1, -32, 0, 32)
title.TextXAlignment = Enum.TextXAlignment.Left

local slotCount = makeLabel(panel, "", 16)
slotCount.Position = UDim2.fromOffset(16, 8)
slotCount.Size = UDim2.new(1, -32, 0, 32)
slotCount.TextColor3 = COLOURS.muted
slotCount.TextXAlignment = Enum.TextXAlignment.Right

local grid = Instance.new("ScrollingFrame")
grid.Position = UDim2.fromOffset(12, 48)
grid.Size = UDim2.new(1, -24, 1, -100)
grid.BackgroundTransparency = 1
grid.BorderSizePixel = 0
grid.CanvasSize = UDim2.new() -- AutomaticCanvasSize gjør den større etter cellene
grid.AutomaticCanvasSize = Enum.AutomaticSize.Y
grid.ScrollingDirection = Enum.ScrollingDirection.Y
grid.ScrollBarThickness = 6
grid.Parent = panel

local layout = Instance.new("UIGridLayout")
layout.CellSize = UDim2.fromOffset(72, 72)
layout.CellPadding = UDim2.fromOffset(8, 8)
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = grid

local info = makeLabel(panel, "Click an item to equip or use it.", 16)
info.AnchorPoint = Vector2.new(0, 1)
info.Position = UDim2.new(0, 16, 1, -8)
info.Size = UDim2.new(1, -32, 0, 40)
info.Font = Enum.Font.BuilderSans
info.TextColor3 = COLOURS.muted
info.TextWrapped = true
info.TextXAlignment = Enum.TextXAlignment.Left

-- 2. Én celle per slot. Dette tegner bare det serveren sendte; selve
-- inventaret endres aldri herfra.
local function makeCell(index: number, slot: Slot?, equippedId: string?)
	local cell = Instance.new("TextButton")
	cell.LayoutOrder = index
	cell.Text = ""
	cell.AutoButtonColor = slot ~= nil
	cell.BackgroundColor3 = if slot then COLOURS.slot else COLOURS.empty
	addCorner(cell, 8)
	cell.Parent = grid
	if not slot then
		return -- tom slot
	end

	local itemId = slot.id
	local item = ItemCatalog.get(itemId)
	local name = if item then item.name else itemId

	if item and item.icon then
		local image = Instance.new("ImageLabel")
		image.BackgroundTransparency = 1
		image.Size = UDim2.fromScale(1, 1)
		image.Image = item.icon
		image.Parent = cell
	else
		local nameLabel = makeLabel(cell, name, 14)
		nameLabel.Size = UDim2.fromScale(1, 1)
		nameLabel.TextWrapped = true
	end

	if slot.count > 1 then
		local countLabel = makeLabel(cell, `x{slot.count}`, 14)
		countLabel.AnchorPoint = Vector2.new(1, 1)
		countLabel.Position = UDim2.new(1, -6, 1, -4)
		countLabel.Size = UDim2.fromOffset(40, 16)
		countLabel.TextXAlignment = Enum.TextXAlignment.Right
	end

	if itemId == equippedId then
		local outline = Instance.new("UIStroke")
		outline.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
		outline.Color = COLOURS.equipped
		outline.Thickness = 3
		outline.Parent = cell
	end

	cell.MouseEnter:Connect(function()
		info.Text = if item then `{item.name}: {item.description}` else name
	end)
	cell.Activated:Connect(function()
		-- Vi ber, vi befaler ikke: serveren sjekker forespørselen og sender resultatet
		if item and item.toolName then
			equipItem:FireServer(itemId)
		elseif item and item.heal then
			useItem:FireServer(itemId)
		end
	end)
end

local function render(snapshot: Snapshot)
	for _, child in grid:GetChildren() do
		if child:IsA("GuiButton") then
			child:Destroy()
		end
	end
	for index = 1, snapshot.capacity do
		makeCell(index, snapshot.slots[index], snapshot.equipped)
	end
	slotCount.Text = `{#snapshot.slots} / {snapshot.capacity} slots`
end

-- Serveren sender dette etter lasting og etter hver endring
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Vi åpner og lukker med knappen eller tasten B
local function toggle()
	panel.Visible = not panel.Visible
end

openButton.Activated:Connect(toggle)
UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessedEvent: boolean)
	if not gameProcessedEvent and input.KeyCode == TOGGLE_KEY then
		toggle()
	end
end)

Et LocalScript i StarterPlayerScripts kjører én gang per økt, og ResetOnSpawn = false beholder ScreenGui når karakteren respawner, så rutenettet fortsetter å vise den siste kopien serveren sendte.

Klienten tegner én celle for hver slot, også de tomme, så et inventar på 20 slots ser alltid ut som 20 slots. Hver oppdatering ødelegger de gamle cellene og bygger nye, det er enkelt og passer for noen titalls slots. Hvis serveren sender InventoryUpdated før dette skriptet har koblet seg til den, setter Roblox meldingen i kø og leverer den så snart handleren kobles til, så det første inventaret går ikke tapt.

Vil du tegne vinduet i Studio? Bygg en ScreenGui med én mal-slot og bruk Clone på den i makeCell. For ikoner gir du gjenstanden i katalogen en icon med et bilde du har lastet opp, så viser cellen bildet i stedet for navnet.

Test inventaret

  1. Trykk Play. Åpne inventaret med knappen til venstre eller tasten B: en ny spiller har Sword og 3 Apple, og telleren viser 2 / 20 slots. Så lenge Studio ikke kan bruke datastores, dukker gjenstandene opp etter noen sekunder, etter advarsler om lastingen i Output, og de lagres ikke.
  2. Klikk på Sword. Sverdet dukker opp i hånden din og i hotbaren, og sloten får en lilla ramme. Klikk igjen for å legge det bort.
  3. Gå bort til Apple-parten og bruk prompten. Eplestacken vokser til 4, og parten forsvinner i 15 sekunder.
  4. For å teste helbredelsen må du først senke helsen. Bytt Client/Server til Server, merk Humanoid til karakteren din i Explorer, sett Health til 50, bytt tilbake til Client og klikk på Apple.
  5. Med Studio sin tilgang til API services slått på stopper du spillet og starter det igjen. Eplet du plukket opp, er der. Hvis lasting eller lagring mislyktes, står det i Output.

For å teste med flere spillere velger du Server & Clients med 2 klienter i testinnstillingene. Hver spiller ser bare sitt eget inventar, og sverdet i hånden til den andre ser begge.

Vanlige feil og løsninger

De fleste problemer vises i Output-vinduet som en advarsel eller en rød feillinje. Les den første: de neste feilene følger ofte av den.

Infinite yield possible på et kall til WaitForChild

Skriptet venter på et objekt som ikke finnes med akkurat det navnet. Sammenlign Explorer med treet fra steg 1: InventoryRemotes med tre RemoteEvent i ReplicatedStorage, ItemTools i ServerStorage og to moduler. Navnene skiller mellom store og små bokstaver. Guiden om skriptfeil går nærmere inn på denne advarselen.

Rutenettet åpnes, men forblir tomt

Klienten tegner bare det serveren sender. Se etter advarsler om Inventory load failed i Output, og sjekk at InventoryData er et Script, ikke et LocalScript, i ServerScriptService, og at ModuleScript-et InventoryService ligger ved siden av. Hvis Output viser feilen Remote event invocation, lytter ingen på InventoryUpdated på klienten: se etter en tidligere feil fra InventoryClient.

Gjenstandene nullstilles hver gang jeg spiller i Studio

Hvis Output skriver Inventory not loaded: playing with starter items that will not be saved, er placen ikke publisert, eller Studio sin tilgang til API services er slått av. Slå den på som beskrevet i steg 4, i en testkopi av spillet ditt.

Å klikke på sverdet gjør ingenting

Se etter Cannot equip sword i Output: Tool i ServerStorage.ItemTools må hete nøyaktig det samme som toolName i katalogen. Et Tool trenger også en part med navnet Handle for å kunne holdes, med mindre du har satt RequiresHandle til false.

Plukkeprompten dukker opp, men ingenting legges til

Attributtet ItemId må være nøyaktig det samme som id-en i katalogen, også store og små bokstaver: apple, ikke Apple. Ingenting legges til mens spillerens inventar fortsatt lastes, eller når det ikke er plass til hele antallet.

Lagringen slutter å virke etter at jeg endret hva som lagres

Datastores tar imot enkle data: strenger, tall, boolske verdier og tabeller av dem. Å lagre et Tool, en Part eller en annen Instance feiler, eller verdien lagres som nil. Lagre gjenstandens id og antall, og gjenopprett resten fra katalogen, slik serialize gjør.

Gjør det med RoCode

Hvis det er enklere for deg å beskrive systemet enn å bygge det for hånd, kan RoCode bygge det i placen du har åpen. Det er en AI-agent for Roblox Studio: du beskriver funksjonen i webchatten, og pluginen for Studio lager skriptene og objektene i Explorer, i stedet for å gi deg kode du må lime inn.

Du skriver

Legg til et inventar med 20 slots og stacks av gjenstander, et rutenett i UI som åpnes med B, et sverd fra ServerStorage som spillerne kan utstyre, epler som helbreder, og lagring med DataStoreService.

RoCode gjør
  • Kan se gjennom placen din når et steg trenger det, med Search Game og Search Scripts, for å bygge på gjenstander, remotes eller lagringskode som allerede finnes, i stedet for å legge til et system nummer to
  • Lager mapper og RemoteEvent med Create Instance, og ModuleScript, Script og LocalScript med Create Script
  • Kan bygge et utkast til vinduet med Build UI, som har en inventarlayout med plassholder-slots; koden som fyller slotsene fra serveren, skrives i egne skript
  • Sjekker at hvert skript kompilerer i Studio med Check Script, som fanger kompileringsfeil og noen risikable mønstre, men ikke sjekker typer, ikke linter og ikke kjører koden din

Hver pakke med endringer er et angrepunkt i Studio. RoCode kan ikke slå på Studio sin tilgang til API services, det gjør du selv. Med plugin 3.9 eller nyere kan den kjøre en kort playtest og lese feilene, og med plugin 3.9.15 eller nyere kan testkarakteren dens trykke på taster og utstyre gjenstander, men den sjekker bare det den selv har bestemt seg for å teste, så test lagringen med en playtest selv. Et inventar bygger på andre systemer, som lagring og verktøy, og AI-spillbyggeren som bygger i din egen place i Studio, legger dem til én prompt om gangen. Slik kobler RoCode seg til Studio.

Ofte stilte spørsmål

Bør jeg bruke Backpack i Roblox i stedet for mitt eget inventar?

Backpack er det innebygde inventaret i Roblox: hvert Tool i det vises som en knapp i hotbaren. Hvis alle gjenstandene i spillet ditt er Tool og du ikke trenger stacks, antall og en grense for slots, kan det holde, selv om du fortsatt må lagre hvilke Tool hver spiller har. Et eget inventar trengs for gjenstander som ikke er Tool, for eksempel materialer og forbruksvarer. Denne guiden bruker begge deler: inventaret holder alt, og Backpack holder det utstyrte Tool.

Hvordan skjuler jeg standard-hotbaren i Roblox?

Kall StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) fra et LocalScript. Når hotbaren er skjult, trenger spillerne en annen måte å ta frem og legge bort det utstyrte Tool på, for eksempel en knapp som ber serveren kalle Humanoid:EquipTool eller Humanoid:UnequipTools.

Hvordan får jeg slots til å holde plassen sin for drag and drop?

Lagre en liste med fast lengde og én oppføring per slot, og merk tomme slots med en verdi som en tom id, ikke nil, fordi Roblox fraråder å sende tabeller med nil via RemoteEvent. Legg så til en RemoteEvent MoveItem som sender to slotnumre, og la serveren sjekke at begge er heltall fra 1 til kapasiteten før de bytter plass.

Hvor stort kan et lagret inventar være?

Én verdi i en datastore kan være opptil 4 194 304 tegn etter serialisering (ifølge dokumentasjonen per 30. september 2026). En liste med id-er og antall tar en bitteliten del av det. Det som får lagringen til å vokse, er tekst per gjenstand, for eksempel egne navn eller lange beskrivelser lagret for hver gjenstand.

Hvordan kjøper og selger jeg gjenstander for mynter?

Gjør alt på serveren. For å selge kaller du InventoryService.remove og betaler bare hvis den ga tilbake true. For å kjøpe sjekker du prisen og spaceFor, trekker myntene og kaller så add. Butikkguiden bygger kjøpssiden.

Kilder og videre lesing

Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.

Prøv RoCode i ditt eget spill.

Gratis credits hver dag, uten kort. Installer pluginen, beskriv en funksjon og se hva som dukker opp i Studio.