Tutorial · Spilsystemer

Sådan laver du et inventar i Roblox Studio

Et inventar ligner en opgave om interfacet, men om det kan hackes, og om det mister ting, afgøres af, hvor tingene gemmes. I denne guide ligger hver spillers ting i en tabel på serveren, hver spiller får en kopi og tegner den som et gitter, udruster Tools og bruger forbrugsvarer via forespørgsler, som serveren tjekker, og alt gemmes i en datastore.

Opdateret 20. november 202616 min. læsningSkrevet af

Kort fortalt

Gem hver spillers ting i en tabel på serveren, inde i et ModuleScript i ServerScriptService, og lad kun den kode tilføje, fjerne og stakke dem. Beskriv tingene én gang i et ModuleScript i ReplicatedStorage (id, navn, maksimal stak). Efter hver ændring sender serveren en RemoteEvent med en kopi af inventaret til den spiller, og et LocalScript tegner det som et gitter med ScrollingFrame og UIGridLayout.

  • Klienten tilføjer aldrig ting. Den kan kun bede om noget, for eksempel "udrust mit sværd", og serveren tjekker, at spilleren har det, før den gør noget.
  • Ting dukker kun op via server-kode, som du styrer: når de samles op, køb i butikken efter tjek på serveren, belønninger.
  • Gem tingenes id og antal, ikke Tools, med DataStoreService, når spilleren går, når serveren lukker, og med nogle minutters mellemrum. Gem aldrig en spiller, hvis data ikke blev indlæst.
På denne side
  1. Sådan virker det
  2. Hvorfor tingene ligger på serveren
  3. 1. Forbered Explorer
  4. 2. Katalog
  5. 3. Inventar på serveren
  6. 4. Indlæs og gem
  7. 5. Opsamling
  8. 6. Udrustning og brug
  9. 7. UI-gitter
  10. Test
  11. Common errors
  12. Med RoCode
  13. Ofte stillede spørgsmål
  14. Kilder og videre læsning

Sådan er et inventar bygget op

IllustrationTryk på B, hold markøren over en ting for at læse beskrivelsen, og klik på Sword for at tage det i hånden.

Systemet består af seks små dele, hver med én opgave. Alle regler om ting bor i ét servermodul, så når noget går i stykker, skal du kun lede ét sted.

Systemets dele, og hvor de kører
DelType og placeringOpgave
ItemCatalogModuleScript i ReplicatedStorageHvad hver ting er: navn, beskrivelse, maksimal stak, og om den kan udrustes eller bruges. Serveren og alle klienter læser det.
InventoryServiceModuleScript i ServerScriptServiceHolder alle spilleres slots. Den eneste kode, der tilføjer, fjerner og stakker ting.
InventoryDataScript i ServerScriptServiceIndlæser spillerens ting ved indgang og gemmer dem.
InventoryActionsScript i ServerScriptServiceTjekker og udfører forespørgsler om udrustning og brug.
ItemPickupScript inde i en PartGiver tingen til den, der samlede den op.
InventoryClientLocalScript i StarterPlayerScriptsTegner gitteret og sender forespørgsler. Ændrer ikke selv noget.

Data går i én retning. Serveren ændrer inventaret, sender derefter InventoryUpdated med hele inventaret til den spiller, og klienten tegner det igen. Når spilleren klikker på et slot, sender klienten EquipItem eller UseItem med tingens id; serveren tjekker forespørgslen, laver ændringen, og den nye kopi kommer samme vej. Det er enklere at sende hele inventaret end at sende ændringerne, og til nogle få dusin slots forbliver beskeden lille.

Hvorfor klienten aldrig tilføjer ting

Det er fristende at tilføje en ting direkte i det LocalScript, der viser den: spilleren klikker, og slottet fyldes. Det går i stykker på to måder.

  • Ingen andre ser det. En ændring i et LocalScript findes kun på den spillers enhed. Serveren får ikke noget at vide om den, så den bliver ikke gemt, og intet server-script kan bruge den.
  • Hvem som helst kan forfalske det. Hvis du løser det med en remote som AddItem(itemId, amount), kan en snyder selv kalde det event, med hvilke argumenter som helst og så mange gange, han vil. Roblox' guide til sikkerhed siger, at serveren skal tjekke alt, hvad klienten sender, før det bruges.

Derfor kan klienten i denne guide kun bede om at gøre noget med ting, spilleren allerede har: "udrust den her" og "brug den her". Hver forespørgsel har ét id og ingen antal, og på serveren gennemgår den ét tjek: det er en streng, tingen findes, spilleren har mindst én, og spilleren sender højst fire forespørgsler i sekundet. Derefter finder serveren selv Toolet ud fra kataloget. Den tager aldrig imod et Tool, en sti eller en instans fra klienten, som den samme guide advarer om.

Ting kommer kun ind i inventaret via server-kode: en opsamling, som serveren har tjekket, et køb, som serveren har trukket penge for (det bygger guiden til butikker), en belønning for en quest eller et drop. Om remotes generelt, med tjek af andre slags argumenter, kan du læse i guiden til RemoteEvent.

Trin 1: forbered Explorer

Opret disse objekter i hånden. Scriptene i de næste trin leder efter dem via navn, så skriv hvert navn præcis som her.

  1. Indsæt en Folder med navnet InventoryRemotes i ReplicatedStorage. Indsæt tre RemoteEvents i den med navnene InventoryUpdated, EquipItem og UseItem.
  2. Indsæt en Folder med navnet ItemTools i ServerStorage. Indsæt et Tool med navnet Sword i den, og i Toolet en Part med navnet Handle (1 gange 4 gange 1 studs er helt fint). Tjek, at fluebenet i Anchored er fjernet på Handle: Roblox advarer om, at karakteren sidder fast, hvis den holder et tool med anchored parts. Et Tool, du allerede har, kan også bruges, hvis dets navn passer med kataloget fra trin 2.
  3. Tilføj scriptene, efterhånden som du går gennem trinene. Træet viser, hvor hvert af dem skal ligge.
Explorer, når guiden er gennemført
ReplicatedStorage
  ItemCatalog ModuleScript new
  InventoryRemotes Folder new
    InventoryUpdated RemoteEvent new
    EquipItem RemoteEvent new
    UseItem RemoteEvent new
ServerScriptService
  InventoryService ModuleScript new
  InventoryData Script new
  InventoryActions Script new
ServerStorage
  ItemTools Folder new
    Sword Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    InventoryClient LocalScript new
Workspace
  Apple Part new
    ItemPickup Script new

Trin 2: beskriv tingene i et katalog

Kataloget beskriver hver ting, der kan findes, én gang. Inventarerne gemmer derefter kun tingens id og antal. Så forbliver de gemte data små, og du kan senere omdøbe en ting eller omskrive dens beskrivelse uden at røre ved nogens gemte data.

Indsæt et ModuleScript i ReplicatedStorage, kald det ItemCatalog, og erstat indholdet med dette:

ModuleScript i ReplicatedStorage med navnet ItemCatalog
-- Alle ting, der kan findes i spillet. Denne liste læses af serveren og alle
-- klienter; kun serveren afgør, hvem der har hvad.
export type Item = {
	id: string, -- skal passe med nøglen nedenfor
	name: string,
	description: string,
	maxStack: number, -- hvor mange af denne ting der kan være i ét slot
	icon: string?, -- valgfrit billede: "rbxassetid://" plus ID for dit billede
	toolName: string?, -- Tool i ServerStorage.ItemTools: tingen kan udrustes
	heal: number?, -- hvor meget helbred den giver tilbage: tingen er en forbrugsvare
}

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

local ItemCatalog = {}

-- Returnerer tingen med dette id eller nil, hvis der ikke findes en sådan ting
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

De valgfrie felter bestemmer, hvad en ting gør. toolName gør den udrustbar, heal gør den brugbar, og en ting uden begge felter, som træ, ligger i inventaret, indtil anden server-kode fjerner den (crafting, salg).

For at tilføje en ting skal du tilføje en post, hvor nøglen og id er ens. Id skelner mellem store og små bogstaver, og det er dem, der gemmes, så ændr aldrig et id, når spillere allerede har tingen: ændr dens name.

Trin 3: gem inventarerne på serveren

Dette ModuleScript ejer hver spillers inventar. Hvert inventar er en liste af slots, hvert slot med et id og et antal, plus en kapacitet på 20 slots. Andre server-scripts kalder dets funktioner, og ingen andre redigerer tabellen.

Indsæt et ModuleScript i ServerScriptService, og kald det InventoryService:

ModuleScript i ServerScriptService med navnet InventoryService
-- Den eneste kode, der ændrer inventarer. Den ligger i ServerScriptService,
-- hvor klienterne hverken kan se eller køre den.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Strict mode kan ikke se, hvad require via WaitForChild returnerer, så
-- vi beskriver den del af modulet, som dette script bruger
type Item = { id: string, maxStack: number }
type Catalog = { get: (id: string) -> Item? }
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog

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

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

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

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

local InventoryService = {}

-- Sender ejeren en kopi af inventaret. Kaldes efter hver ændring.
local function sync(player: Player)
	local inventory = inventories[player]
	if inventory then
		inventoryUpdated:FireClient(player, {
			capacity = inventory.capacity,
			slots = inventory.slots,
			equipped = inventory.equipped,
		})
	end
end

-- Regler for stakke: fyld først ufuldstændige stakke op, og start så nye stakke
-- i tomme slots. Returnerer, hvor mange der blev tilføjet, det kan være færre end bedt om.
local function addToInventory(inventory: Inventory, item: Item, amount: number): number
	local remaining = amount
	for _, slot in inventory.slots do
		if remaining == 0 then
			break
		end
		if slot.id == item.id and slot.count < item.maxStack then
			local moved = math.min(item.maxStack - slot.count, remaining)
			slot.count += moved
			remaining -= moved
		end
	end
	while remaining > 0 and #inventory.slots < inventory.capacity do
		local moved = math.min(item.maxStack, remaining)
		table.insert(inventory.slots, { id = item.id, count = moved })
		remaining -= moved
	end
	return amount - remaining
end

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

-- Hvor mange flere af tingen der kan være: plads i dens stakke plus tomme slots
function InventoryService.spaceFor(player: Player, itemId: string): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	if not inventory or not item then
		return 0
	end
	local space = (inventory.capacity - #inventory.slots) * item.maxStack
	for _, slot in inventory.slots do
		if slot.id == itemId then
			space += item.maxStack - slot.count
		end
	end
	return space
end

-- Tilføjer op til amount stk. af tingen. Returnerer, hvor mange der blev tilføjet (0, hvis
-- tingen ikke findes, inventaret er fuldt eller endnu ikke indlæst).
function InventoryService.add(player: Player, itemId: string, amount: number): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	local wanted = math.floor(amount)
	if not inventory or not item or wanted < 1 then
		return 0
	end
	local added = addToInventory(inventory, item, wanted)
	if added > 0 then
		sync(player)
	end
	return added
end

-- Fjerner præcis amount stk. af tingen, begyndende med de sidste stakke.
-- Hvis spilleren har færre, fjernes intet, og der returneres false.
function InventoryService.remove(player: Player, itemId: string, amount: number): boolean
	local inventory = inventories[player]
	local wanted = math.floor(amount)
	if not inventory or wanted < 1 or InventoryService.count(player, itemId) < wanted then
		return false
	end
	local remaining = wanted
	-- Vi går bagfra, så table.remove ikke springer slots over
	for index = #inventory.slots, 1, -1 do
		local slot = inventory.slots[index]
		if slot.id == itemId then
			local taken = math.min(slot.count, remaining)
			slot.count -= taken
			remaining -= taken
			if slot.count == 0 then
				table.remove(inventory.slots, index)
			end
			if remaining == 0 then
				break
			end
		end
	end
	sync(player)
	return true
end

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

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

-- Kaldes, når spillerens gemte data er indlæst. saved er det, som
-- datastore returnerede: nil for en ny spiller. Hver post går igen gennem
-- reglerne for stakke, så fjernede ting og gamle stakstørrelser ikke ødelægger noget.
function InventoryService.load(player: Player, saved: any)
	local inventory: Inventory = { slots = {}, capacity = CAPACITY }
	local entries: { Slot } = STARTER_ITEMS
	if type(saved) == "table" and type(saved.slots) == "table" then
		entries = {}
		for _, entry in saved.slots do
			if type(entry) == "table" and type(entry.id) == "string" and type(entry.count) == "number" then
				table.insert(entries, { id = entry.id, count = math.floor(entry.count) })
			end
		end
	end
	for _, entry in entries do
		local item = ItemCatalog.get(entry.id)
		if item and entry.count > 0 then
			addToInventory(inventory, item, entry.count)
		end
	end
	inventories[player] = inventory
	sync(player)
end

-- En simpel kopi til gemning eller nil, hvis spillerens data aldrig blev indlæst
function InventoryService.serialize(player: Player): { version: number, slots: { Slot } }?
	local inventory = inventories[player]
	if not inventory then
		return nil
	end
	local slots: { Slot } = {}
	for index, slot in inventory.slots do
		slots[index] = { id = slot.id, count = slot.count }
	end
	return { version = 1, slots = slots }
end

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

return InventoryService

Linjerne med type og castet :: efter require er kun til Luaus typetjekker, som ikke kan se, hvad et modul fundet via WaitForChild returnerer. Under spillet ændrer de ingenting. De andre scripts i denne guide gør det samme.

Sådan virker reglerne for stakke med kataloget ovenfor, hvor æbler stakkes op til 10:

  • Hvis du tilføjer 15 æbler til en spiller med en stak på 7, fyldes den stak op til 10, og så starter en ny stak på 5.
  • Når der ikke er flere slots, tilføjer add det, der var plads til, og returnerer det tal. Kald først spaceFor, når det skal være alt eller intet, som opsamlingen i trin 5 gør.
  • remove virker efter princippet alt eller intet. En forespørgsel på 3 æbler hos en spiller, der har 2, fjerner intet og returnerer false, så tjek resultatet, før du giver noget til gengæld.
  • Der er ingen huller i slots: når et slot bliver tomt, rykker de andre op. Så er listen nemmere at sende og gemme. Slots, der holder deres position, beskrives i spørgsmålene til sidst.
Hvad andre server-scripts kan kalde
FunktionReturnererTil hvad
add(player, itemId, amount)Hvor mange der blev tilføjetOpsamling, belønninger, køb
remove(player, itemId, amount)true, hvis alt blev fjernetBrug, salg, crafting
count(player, itemId)Summen over alle stakkeTjekke, hvad spilleren har
spaceFor(player, itemId)Hvor mange flere der kan væreTjek før tilføjelse efter princippet alt eller intet
getEquipped, setEquippedId på den udrustede ting eller nilUdrustning, i trin 6
load, serialize, unloadEn kopi klar til gemning (serialize)Indlæsning og gemning, i trin 4

Trin 4: indlæs og gem hvert inventar

Inventarer lever i serverens hukommelse, så de forsvinder, når spilleren går. Dette script indlæser spillerens slots fra en datastore, når spilleren kommer ind, og skriver dem tilbage, når spilleren går, når serveren lukker, og hvert tredje minut i tilfælde af et servernedbrud. Det gemmer kun tingenes id og antal: datastores kan ikke gemme en Instance, for eksempel et Tool.

Indsæt et Script i ServerScriptService, og kald det InventoryData:

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

-- Kun spillere, hvis data blev indlæst, gemmes. Efter en mislykket indlæsning
-- må der ikke gemmes, ellers erstatter et tomt inventar det rigtige.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Én mislykket forespørgsel må ikke koste nogen deres ting, så vi prøver flere gange.
-- GetDataStore er også inde i pcall, så en Studio-session uden adgang til
-- datastores får en advarsel i stedet for at stoppe dette script.
local function loadSaved(player: Player): (boolean, any)
	for attempt = 1, LOAD_ATTEMPTS do
		local ok, result = pcall(function()
			return DataStoreService:GetDataStore(STORE_NAME):GetAsync(keyFor(player))
		end)
		if ok then
			return true, result
		end
		warn(`Inventory load failed for {player.Name} (attempt {attempt}): {result}`)
		if attempt < LOAD_ATTEMPTS then
			task.wait(attempt * 2)
		end
	end
	return false, nil
end

local function onPlayerAdded(player: Player)
	local ok, saved = loadSaved(player)
	if player.Parent ~= Players then
		return -- spilleren gik, mens vi indlæste
	end
	if ok then
		InventoryService.load(player, saved) -- saved er nil for en ny spiller
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Betyder som regel, at Studios adgang til API services er slået fra. Vi spiller med
		-- startting, så der kan testes, men gemmer dem aldrig.
		warn("Inventory not loaded: playing with starter items that will not be saved")
		InventoryService.load(player, nil)
	else
		player:Kick("Your inventory could not be loaded. Please rejoin in a minute.")
	end
end

local function save(player: Player)
	if not canSave[player] then
		return -- dataene blev aldrig indlæst, der er intet, der er sikkert at skrive
	end
	local data = InventoryService.serialize(player)
	if not data then
		return
	end
	activeSaves += 1
	local ok, err = pcall(function()
		DataStoreService:GetDataStore(STORE_NAME):SetAsync(keyFor(player), data, { player.UserId })
	end)
	activeSaves -= 1
	if not ok then
		warn(`Inventory save failed for {player.Name}: {err}`)
	end
end

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

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

-- Når serveren lukker, gemmer vi alle, der stadig er her, og venter på hver
-- igangværende gemning, inklusive dem, PlayerRemoving startede
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Gem alle med nogle minutters mellemrum, så et servernedbrud koster minutter og ikke hele sessionen
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Hvad scriptet gør, og hvorfor:

  • Indlæsning med standardværdier. En ny spiller har ingen gemt værdi, så GetAsync returnerer nil, og spilleren får startting. Gemte slots går igen gennem reglerne for stakke, så en ting, der er fjernet fra kataloget, eller en mindre maksimal stak ikke ødelægger indlæsningen. Alt, der ikke længere er plads til, eller hvis id ikke længere findes i kataloget, smides væk, og den næste gemning gør det endeligt, så behold hvert id, som spillere kan have, i kataloget.
  • Gem aldrig efter en mislykket indlæsning. Kun spillere i canSave bliver skrevet. På en rigtig server bliver en spiller, hvis data ikke blev indlæst selv efter tre forsøg, bedt om at komme ind igen. I Studio får spilleren i stedet startting, der ikke gemmes, nogle sekunder senere på grund af de gentagne forsøg. Sådan er det, indtil dit place er udgivet med adgang til API slået til.
  • Gemning ved udgang og ved lukning. BindToClose gemmer alle, der stadig er på serveren, og venter på gemninger, der allerede er i gang. Roblox giver bundne funktioner op til 30 sekunder.
  • Hold dig inden for grænserne. Én skrivning pr. spiller hvert tredje minut plus én ved udgang er langt under en servers standardbudget på 60 skrivninger i minuttet plus 40 for hver spiller (ifølge dokumentationen pr. 30. september 2026). Nøglemønsteret User_ kommer fra Roblox' anbefalinger, og at sende user ID med i SetAsync knytter dataene til den spiller, hvilket Roblox kraftigt anbefaler for at kunne håndtere anmodninger om sletning af data.

Til et lille spil er det et solidt fundament. Session locking, som forhindrer en spiller, der hurtigt skifter server, i at indlæse data, før den gamle server har gemt dem, og hvornår du skal bruge UpdateAsync i stedet for SetAsync, gennemgås i tutorialen om DataStore.

Trin 5: giv ting fra verden

Opsamling er den enkleste måde, ting kommer ind i inventaret på: en part med en ProximityPrompt, der tilføjer tingen, når spilleren bruger den. Scriptet lytter efter dens event Triggered på serveren, så tingen tilføjes dér, hvor klienten ikke kan blande sig.

  1. Tilføj en Part i Workspace, kald den Apple, og farv den rød. Slå Anchored til og CanCollide fra, så ingen støder ind i den, mens den er usynlig. Prompten viser partens navn.
  2. Med parten markeret skal du rulle ned i vinduet Properties til afsnittet Attributes og klikke på +. Tilføj ItemId af typen string, klik på Save, og sæt derefter værdien til apple. Tilføj på samme måde Amount af typen number med værdien 1.
  3. Indsæt et Script i parten, kald det ItemPickup, og sæt denne kode ind:
Script i parten Apple i Workspace med navnet ItemPickup
-- Læg dette Script inde i en Part, og giv parten to attributter:
-- ItemId (en streng, for eksempel apple) og Amount (et tal, for eksempel 1).
local ServerScriptService = game:GetService("ServerScriptService")

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

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

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

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

local visibleTransparency = part.Transparency

prompt.Triggered:Connect(function(player: Player)
	if not prompt.Enabled then
		return -- en anden har lige samlet den op
	end
	-- Tjek afstanden på serveren i stedet for at stole på forespørgslen
	local character = player.Character
	if not character then
		return
	end
	local distance = (character:GetPivot().Position - part.Position).Magnitude
	if distance > prompt.MaxActivationDistance + 5 then
		return
	end
	if InventoryService.spaceFor(player, itemId) < amount then
		return -- ikke plads nok: lad tingen blive liggende
	end
	InventoryService.add(player, itemId, amount)

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

Kopiér parten for at placere flere ting. Ændr attributterne for at give træ, endnu et sværd eller en stak æbler.

Roblox tjekker afstanden for Triggered, men dets guide til sikkerhed siger alligevel, at du skal tjekke prompts på serveren: en snyder kan udløse promptens events, selv når Enabled er false, og kan trække en part, der ikke er anchored, hen til sin karakter. Derfor tjekker scriptet selv Enabled og afstanden, og derfor er parten anchored.

Ethvert andet server-script giver ting på samme måde. Efter et køb, en quest eller et drab skal du hente InventoryService med require, som scriptene ovenfor, og kalde InventoryService.add(player, "wood", 5). Tjek først spaceFor, når tingen ikke må gå tabt. En NPC kan også være en kilde: i guiden til NPC-dialoger starter et svar en handling på serveren, og den handling kan på samme måde kalde InventoryService.add.

Trin 6: udrust Tools og brug ting

To RemoteEvents bærer de eneste forespørgsler, klienten kan sende. EquipItem lægger en kopi af tingens Tool fra ServerStorage i spillerens Backpack (hotbaren nederst på skærmen) og i spillerens hånd, og en ny forespørgsel lægger den væk. UseItem fjerner ét stk. af en brugbar ting og anvender dens effekt, her heling.

Indsæt et Script i ServerScriptService, og kald det InventoryActions:

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ørgsel starter her. Klienten kan sende hvad som helst når som helst, så
-- vi tjekker typen, at tingen findes, at spilleren har den, og hyppigheden.
local function ownedItem(player: Player, itemId: unknown): Item?
	if typeof(itemId) ~= "string" then
		return nil
	end
	local now = os.clock()
	if now - (lastRequest[player] or 0) < COOLDOWN_SECONDS then
		return nil
	end
	lastRequest[player] = now
	local item = ItemCatalog.get(itemId)
	if not item or InventoryService.count(player, itemId) < 1 then
		return nil
	end
	return item
end

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

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

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

	local tool = template:Clone()
	tool.CanBeDropped = false -- en tabt kopi kunne samles op af en anden
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- En ekstra kopi i StarterGear kopieres tilbage til Backpack efter respawn
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		local gearCopy = tool:Clone()
		gearCopy.Parent = starterGear
	end

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

equipItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.toolName then
		return
	end
	if InventoryService.getEquipped(player) == item.id then
		unequip(player) -- et nyt klik på den udrustede ting lægger den væk
	else
		equip(player, item, item.toolName)
	end
end)

useItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.heal then
		return
	end
	local heal = item.heal
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or humanoid.Health >= humanoid.MaxHealth then
		return -- død eller allerede med fuldt helbred: spild ikke tingen
	end
	-- Tag først tingen, og hel kun, hvis det lykkedes
	if InventoryService.remove(player, item.id, 1) then
		humanoid.Health = math.min(humanoid.MaxHealth, humanoid.Health + heal)
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)
Hvad hver forespørgsel må
ForespørgselKlienten senderServeren tjekker før handlingen
EquipItemTingens idDet er en streng, tingen findes, spilleren har den, forespørgslerne kommer højst fire gange i sekundet, tingen har et toolName, og et Tool med det navn ligger i ServerStorage.ItemTools
UseItemTingens idDe samme tjek af type, ejerskab og hyppighed, tingen har en værdi heal, karakteren er i live og såret, og én ting er fjernet, før helbredet lægges til

Tre detaljer forhindrer et Tool i at blive fordoblet eller gå tabt. Kopien har CanBeDropped sat til false, fordi et tabt Tool falder ned i Workspace, hvor en anden spiller kan tage det, mens originalen bliver i inventaret. Hver kopi har attributten InventoryItem, så du ved aflægning kan finde og ødelægge hver kopi, hvor den end er. Og hvis spilleren har en container StarterGear, lægges en ekstra kopi i den. Roblox kopierer StarterGear til Backpack, hver gang karakteren dukker op, så et udrustet sværd kommer tilbage efter respawn.

Kun ét Tool er udrustet ad gangen, og udrustningen gemmes ikke, så spilleren starter med en tom hotbar efter at være kommet ind igen. Hvis du senere tilføjer salg eller at smide ting væk, så aflæg tingen, før dens sidste kopi forlader inventaret.

Pladsholder-sværdet kan gøres til et sværd, der virkelig kæmper: byg Toolet med guiden til sværd, behold navnet Sword, og læg det i ItemTools i stedet for pladsholderen. Server-scriptet fra den guide tjekker hvert slag, uanset hvordan spilleren har fået sværdet.

Trin 7: tegn inventargitteret

LocalScriptet bygger hele vinduet i kode, så intet skal placeres i hånden. ScrollingFrame holder slots, UIGridLayout inde i den lægger dem i rækker, og AutomaticCanvasSize gør det rullbare område større, efterhånden som der kommer flere rækker.

Åbn StarterPlayer i Explorer, indsæt et LocalScript i StarterPlayerScripts, og kald det InventoryClient:

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. Byg vinduet én gang. ResetOnSpawn = false bevarer det efter respawns.
local gui = Instance.new("ScreenGui")
gui.Name = "InventoryGui"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

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

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

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

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

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

local grid = Instance.new("ScrollingFrame")
grid.Position = UDim2.fromOffset(12, 48)
grid.Size = UDim2.new(1, -24, 1, -100)
grid.BackgroundTransparency = 1
grid.BorderSizePixel = 0
grid.CanvasSize = UDim2.new() -- AutomaticCanvasSize gør det større, så cellerne passer
grid.AutomaticCanvasSize = Enum.AutomaticSize.Y
grid.ScrollingDirection = Enum.ScrollingDirection.Y
grid.ScrollBarThickness = 6
grid.Parent = panel

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

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

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

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

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

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

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

	cell.MouseEnter:Connect(function()
		info.Text = if item then `{item.name}: {item.description}` else name
	end)
	cell.Activated:Connect(function()
		-- Bed i stedet for at beordre: serveren tjekker forespørgslen og sender resultatet
		if item and item.toolName then
			equipItem:FireServer(itemId)
		elseif item and item.heal then
			useItem:FireServer(itemId)
		end
	end)
end

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

-- Serveren sender dette efter indlæsning og efter hver ændring
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Åbn og luk med knappen eller tasten B
local function toggle()
	panel.Visible = not panel.Visible
end

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

Et LocalScript i StarterPlayerScripts kører én gang pr. session, og ResetOnSpawn = false bevarer ScreenGuien, når karakteren respawner, så gitteret fortsat viser den sidste kopi, serveren sendte.

Klienten tegner én celle for hvert slot, også de tomme, så et inventar med 20 slots altid ser ud som 20 slots. Hver opdatering ødelægger de gamle celler og bygger nye, det er enkelt og passer til nogle få dusin slots. Hvis serveren sender InventoryUpdated, før dette script har forbundet sig til det, sætter Roblox beskeden i kø og leverer den, så snart handleren er forbundet, så det første inventar ikke går tabt.

Vil du tegne vinduet i Studio? Byg en ScreenGui med ét skabelon-slot, og lav Clone af det i makeCell. Til ikoner skal du give tingen i kataloget et icon med et billede, du selv har uploadet, så viser dens celle billedet i stedet for navnet.

Test inventaret

  1. Tryk på Play. Åbn inventaret med knappen til venstre eller tasten B: en ny spiller har Sword og 3 Apple, og tælleren viser 2 / 20 slots. Så længe Studio ikke kan bruge datastores, dukker tingene op efter nogle sekunder, efter advarsler om indlæsning i Output, og bliver ikke gemt.
  2. Klik på Sword. Sværdet dukker op i din hånd og i hotbaren, og dets slot får en lilla ramme. Klik igen for at lægge det væk.
  3. Gå hen til parten Apple, og brug dens prompt. Stakken af æbler vokser til 4, og parten forsvinder i 15 sekunder.
  4. For at teste heling skal du først sænke helbredet. Skift Client/Server til Server, markér din karakters Humanoid i Explorer, sæt Health til 50, skift tilbage til Client, og klik på Apple.
  5. Med Studios adgang til API services slået til skal du stoppe spillet og starte det igen. Det opsamlede æble er der stadig. Hvis indlæsning eller gemning mislykkedes, siger Output det.

For at teste med flere spillere skal du vælge Server & Clients med 2 klienter i testindstillingerne. Hver spiller ser kun sit eget inventar, og et sværd i den andens hånd ser begge.

Almindelige fejl og løsninger

De fleste problemer kan ses i vinduet Output som en advarsel eller en rød fejllinje. Læs den første: de følgende fejl skyldes ofte den.

Infinite yield possible på et kald til WaitForChild

Scriptet venter på et objekt, der ikke findes med præcis det navn. Sammenlign din Explorer med træet fra trin 1: InventoryRemotes med tre RemoteEvents i ReplicatedStorage, ItemTools i ServerStorage og to moduler. Navne skelner mellem store og små bogstaver. Guiden til script-fejl gennemgår denne advarsel nærmere.

Gitteret åbner, men forbliver tomt

Klienten tegner kun det, serveren sender. Kig efter advarsler Inventory load failed i Output, og tjek, at InventoryData er et Script og ikke et LocalScript i ServerScriptService, og at ModuleScriptet InventoryService ligger ved siden af. Hvis Output viser fejlen Remote event invocation, er der ingen på klienten, der lytter efter InventoryUpdated: kig efter en tidligere fejl fra InventoryClient.

Tingene nulstilles, hver gang jeg spiller i Studio

Hvis Output skriver Inventory not loaded: playing with starter items that will not be saved, er dit place ikke udgivet, eller Studios adgang til API services er slået fra. Slå den til som beskrevet i trin 4, i en testkopi af dit spil.

Et klik på sværdet gør ingenting

Kig efter Cannot equip sword i Output: Toolet i ServerStorage.ItemTools skal hedde præcis som toolName i kataloget. Toolet skal også have en part med navnet Handle, så det kan holdes, medmindre du har sat dets RequiresHandle til false.

Opsamlingsprompten dukker op, men intet bliver tilføjet

Attributten ItemId skal passe præcis med id i kataloget, inklusive store og små bogstaver: apple, ikke Apple. Intet bliver tilføjet, mens spillerens inventar stadig indlæses, eller når der ikke er plads til hele antallet.

Gemning går i stykker, efter at jeg ændrede, hvad der gemmes

Datastores tager imod simple data: strenge, tal, booleans og tabeller af dem. At gemme et Tool, en Part eller en anden Instance mislykkes, eller værdien gemmes som nil. Gem tingens id og antal, og genskab resten ud fra kataloget, som serialize gør.

Lav det med RoCode

Hvis det er nemmere for dig at beskrive systemet end at bygge det i hånden, kan RoCode bygge det i det place, du har åbent. Det er en AI-agent til Roblox Studio: du beskriver funktionen i webchatten, og dens Studio-plugin opretter scripts og objekter i din Explorer i stedet for at give dig kode, du skal sætte ind.

Du skriver

Tilføj et inventar med 20 slots og stakke af ting, et UI-gitter, der åbner med B, et sværd fra ServerStorage, som spillerne kan udruste, æbler, der heler, og gemning med DataStoreService.

RoCode gør
  • Kan gennemse dit place, når et trin kræver det, med Search Game og Search Scripts, så den bygger på eksisterende ting, remotes eller gemmekode i stedet for at tilføje et ekstra system
  • Opretter mapper og RemoteEvents med Create Instance og ModuleScripts, Scripts og LocalScripts med Create Script
  • Kan bygge et udkast til vinduet med Build UI, som har et inventarlayout med pladsholder-slots; koden, der udfylder slots fra serveren, skrives i separate scripts
  • Tjekker kompileringen af hvert script i Studio med Check Script, som fanger kompileringsfejl og nogle risikable mønstre, men ikke tjekker typer, ikke linter og ikke kører din kode

Hver omgang ændringer er et fortryd-punkt i Studio. RoCode kan ikke slå Studios adgang til API services til, det gør du selv. Med plugin 3.9 eller nyere kan den køre en kort playtest og læse fejlene, og med plugin 3.9.15 eller nyere kan dens testkarakter trykke på taster og udruste ting, men den tjekker kun det, den selv har valgt at teste, så test selv gemningen med en playtest. Et inventar ligger oven på andre systemer, som gemning og tools, og AI-spilbyggeren, der bygger i dit eget place i Studio, tilføjer dem én prompt ad gangen. Sådan forbinder RoCode til Studio.

Ofte stillede spørgsmål

Skal jeg bruge Backpack i Roblox i stedet for mit eget inventar?

Backpack er Roblox' indbyggede inventar: hvert Tool i det vises som en knap i hotbaren. Hvis alle ting i dit spil er Tools, og du ikke har brug for stakke, antal og en grænse for slots, kan den være nok, selvom du stadig skal gemme, hvilke Tools hver spiller har. Et eget inventar skal bruges til ting, der ikke er Tools, for eksempel materialer og forbrugsvarer. Denne guide bruger begge: inventaret holder alt, og Backpack holder det udrustede Tool.

Hvordan skjuler man standard-hotbaren i Roblox?

Kald StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) fra et LocalScript. Når hotbaren er skjult, skal spillerne have en anden måde at tage og lægge et udrustet Tool væk på, for eksempel en knap, der beder serveren om at kalde Humanoid:EquipTool eller Humanoid:UnequipTools.

Hvordan får man slots til at holde deres position til drag and drop?

Gem en liste med fast længde med én post pr. slot, og markér tomme slots med en værdi som et tomt id i stedet for nil, fordi Roblox fraråder at sende tabeller med nil via en RemoteEvent. Tilføj derefter en RemoteEvent MoveItem, der sender to slotnumre, og lad serveren tjekke, at begge er heltal fra 1 til kapaciteten, før de byttes om.

Hvor stort kan et gemt inventar være?

Én værdi i en datastore kan fylde op til 4 194 304 tegn efter serialisering (ifølge dokumentationen pr. 30. september 2026). En liste med id og antal fylder en lillebitte del af det. Det, der får gemningen til at vokse, er tekst for hver ting, for eksempel egne navne eller lange beskrivelser gemt for hver ting.

Hvordan køber og sælger man ting for mønter?

Gør alt på serveren. For at sælge skal du kalde InventoryService.remove og kun betale, hvis den returnerede true. For at købe skal du tjekke prisen og spaceFor, tage mønterne og derefter kalde add. Guiden til butikker bygger købssiden.

Kilder og videre læsning

Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.

Prøv RoCode i dit eget spil.

Gratis credits hver dag, intet kort. Installér pluginet, beskriv en funktion, og se hvad der dukker op i Studio.