Tutoriál · Herní systémy

Jak udělat inventář v Roblox Studiu

Inventář vypadá jako úkol pro rozhraní, ale to, jestli se dá hacknout a jestli ztrácí předměty, rozhoduje místo, kde jsou předměty uložené. V tomto návodu leží předměty každého hráče v tabulce na serveru, každý hráč dostane kopii a vykreslí ji jako mřížku, vybavuje Tool a používá spotřební předměty přes požadavky, které kontroluje server, a všechno se ukládá do data store.

Aktualizováno 20. listopadu 202614 min čteníAutor:

Ve zkratce

Předměty každého hráče držte v tabulce na serveru, uvnitř ModuleScriptu v ServerScriptService, a jen tento kód je smí přidávat, odebírat a skládat do stacků. Předměty popište jednou v ModuleScriptu v ReplicatedStorage (id, název, maximální stack). Po každé změně server pošle tomuto hráči RemoteEvent s kopií jeho inventáře a LocalScript ji vykreslí jako mřížku přes ScrollingFrame a UIGridLayout.

  • Klient nikdy nepřidává předměty. Může jen požádat, například "vybav můj meč", a server ověří, že ho hráč má, než cokoli udělá.
  • Předměty se objevují jen přes serverový kód, který ovládáte: sebrání, nákupy v obchodě po kontrole na serveru, odměny.
  • Ukládejte id předmětů a jejich počty, ne Tool, přes DataStoreService, když hráč odchází, když se server vypíná a jednou za pár minut. Nikdy neukládejte hráče, jehož data se nenačetla.
Na této stránce
  1. Jak je postavený
  2. Proč předměty na serveru
  3. 1. Příprava Exploreru
  4. 2. Katalog předmětů
  5. 3. Inventář na serveru
  6. 4. Načítání a ukládání
  7. 5. Sebrání předmětů
  8. 6. Vybavení a použití
  9. 7. Mřížka UI
  10. Test
  11. Common errors
  12. S RoCode
  13. Časté otázky
  14. Zdroje a další čtení

Jak je inventář postavený

IlustraceStiskněte B, najeďte myší na předmět a přečtěte si popis, klikněte na Sword a vezmete ho do ruky.

Systém se skládá ze šesti malých částí a každá má jeden úkol. Všechna pravidla o předmětech žijí v jednom serverovém modulu, takže když se něco rozbije, hledáte přesně na jednom místě.

Části systému a kde běží
ČástTyp a místoÚkol
ItemCatalogModuleScript v ReplicatedStorageCo je každý předmět: název, popis, maximální stack a jestli se dá vybavit nebo použít. Čte ho server i všichni klienti.
InventoryServiceModuleScript v ServerScriptServiceDrží sloty všech hráčů. Jediný kód, který přidává, odebírá a skládá předměty do stacků.
InventoryDataScript v ServerScriptServiceNačte předměty hráče při vstupu a ukládá je.
InventoryActionsScript v ServerScriptServiceOvěřuje a provádí požadavky na vybavení a použití.
ItemPickupScript uvnitř PartDá předmět tomu, kdo ho sebral.
InventoryClientLocalScript ve StarterPlayerScriptsKreslí mřížku a posílá požadavky. Sám nic nemění.

Data tečou jedním směrem. Server změní inventář, pak tomuto hráči pošle InventoryUpdated s celým inventářem a klient ho překreslí. Když hráč klikne na slot, klient pošle EquipItem nebo UseItem s id předmětu; server požadavek ověří, provede změnu a nová kopie přijde stejnou cestou. Posílat celý inventář je jednodušší než posílat změny a pro pár desítek slotů zůstává zpráva malá.

Proč klient nikdy nepřidává předměty

Láká přidat předmět přímo v LocalScriptu, který ho zobrazuje: hráč klikl, slot se zaplnil. To se rozbije dvěma způsoby.

  • Nikdo jiný to nevidí. Změna v LocalScriptu existuje jen na zařízení tohoto hráče. Server se o ní nedozví, takže se neuloží a žádný serverový skript ji nemůže použít.
  • Podvrhnout to může kdokoli. Pokud to opravíte remotem jako AddItem(itemId, amount), podvodník bude moct tuto událost volat sám, s libovolnými argumenty a kolikrát chce. Návod Robloxu k bezpečnosti říká, že server musí ověřit všechno, co klient pošle, než to použije.

Proto v tomto návodu klient může jen žádat, aby se něco udělalo s předměty, které hráč už má: "vybav tohle" a "použij tohle". Každý požadavek nese jedno id předmětu a žádné počty a na serveru projde jednou kontrolou: je to řetězec, takový předmět existuje, hráč má alespoň jeden a neposílá víc než čtyři požadavky za sekundu. Pak server sám najde Tool podle katalogu. Nikdy od klienta nepřijme Tool, cestu ani instanci, před čímž varuje stejný návod.

Předměty se do inventáře dostanou jen přes serverový kód: sebrání, které ověřil server, nákup, za který server strhl peníze (staví ho návod k obchodu), odměnu za quest nebo drop. O remotech obecně, s kontrolou dalších druhů argumentů, si přečtěte v návodu k RemoteEvent.

Krok 1: připravte Explorer

Vytvořte tyto objekty ručně. Skripty z dalších kroků je hledají podle názvu, proto každý název pište přesně jako tady.

  1. Do ReplicatedStorage vložte Folder s názvem InventoryRemotes. Dovnitř vložte tři RemoteEvent s názvy InventoryUpdated, EquipItem a UseItem.
  2. Do ServerStorage vložte Folder s názvem ItemTools. Dovnitř vložte Tool s názvem Sword a do Toolu Part s názvem Handle (1 na 4 na 1 stud bohatě stačí). Ověřte, že u Handle není zaškrtnuté Anchored: Roblox varuje, že postava uvízne na místě, když drží nástroj s ukotvenými party. Poslouží i Tool, který už máte, pokud jeho název odpovídá katalogu z kroku 2.
  3. Skripty přidávejte postupně podle kroků. Strom ukazuje, kam každý z nich patří.
Explorer po dokončení návodu
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

Krok 2: popište předměty v katalogu

Katalog popíše každý předmět, který může existovat, jednou. Inventáře pak uchovávají jen id předmětu a počet. Uložení tak zůstávají malá a později můžete předmět přejmenovat nebo přepsat jeho popis, aniž byste sáhli na něčí uložená data.

Vložte ModuleScript do ReplicatedStorage, pojmenujte ho ItemCatalog a nahraďte jeho obsah tímto:

ModuleScript v ReplicatedStorage s názvem ItemCatalog
-- Všechny předměty, které mohou ve hře existovat. Tento seznam čte server i všichni
-- klienti; jen server rozhoduje, kdo co má.
export type Item = {
	id: string, -- musí odpovídat klíči níže
	name: string,
	description: string,
	maxStack: number, -- kolik tohoto předmětu se vejde do jednoho slotu
	icon: string?, -- volitelný obrázek: "rbxassetid://" plus ID vašeho obrázku
	toolName: string?, -- Tool v ServerStorage.ItemTools: předmět lze vybavit
	heal: number?, -- kolik zdraví obnoví: předmět je spotřební
}

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

-- Vrátí předmět s tímto id, nebo nil, pokud takový předmět není
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Volitelná pole rozhodují, co předmět dělá. toolName ho udělá vybavitelným, heal použitelným a předmět bez obou polí, jako dřevo, leží v inventáři, dokud ho neodebere jiný serverový kód (crafting, prodej).

Chcete-li přidat předmět, přidejte záznam, jehož klíč a id se shodují. Id rozlišují velikost písmen a právě ona se ukládají, proto id nikdy neměňte, když předmět už hráči mají: měňte jeho name.

Krok 3: držte inventáře na serveru

Tento ModuleScript vlastní inventář každého hráče. Každý inventář je seznam slotů, v každém slotu id předmětu a počet, plus kapacita 20 slotů. Ostatní serverové skripty volají jeho funkce a nikdo jiný tabulku neupravuje.

Vložte ModuleScript do ServerScriptService a pojmenujte ho InventoryService:

ModuleScript v ServerScriptService s názvem InventoryService
-- Jediný kód, který mění inventáře. Leží v ServerScriptService,
-- kde ho klienti nemohou vidět ani spustit.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Strict režim nevidí, co vrací require přes WaitForChild, proto
-- popisujeme tu část modulu, kterou tento skript používá
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 -- slotů na hráče
local STARTER_ITEMS: { Slot } = { -- s čím začíná úplně nový hráč
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Pošle majiteli kopii jeho inventáře. Volá se po každé změně.
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

-- Pravidla stacků: nejdřív doplníme neplné stacky, pak začneme nové stacky
-- v prázdných slotech. Vrátí, kolik se přidalo, může to být méně, než se žádalo.
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

-- Kolik předmětu se ještě vejde: místo v jeho stackách plus prázdné sloty
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

-- Přidá až amount kusů předmětu. Vrátí, kolik se přidalo (0, pokud
-- předmět neexistuje, inventář je plný nebo se ještě nenačetl).
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

-- Odebere přesně amount kusů předmětu, počínaje posledními stacky.
-- Pokud jich hráč má méně, nic neodebere a vrátí 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
	-- Jdeme od konce, aby table.remove nepřeskakoval sloty
	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

-- Volá se, když se uložená data hráče načetla. saved je to, co
-- vrátil data store: nil pro nového hráče. Každý záznam znovu projde
-- pravidly stacků, takže smazané předměty a staré velikosti stacků nic nerozbijí.
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

-- Jednoduchá kopie pro uložení, nebo nil, pokud se data hráče nikdy nenačetla
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

Řádky type a přetypování :: po require potřebuje jen typová kontrola Luau, která nevidí, co vrací modul nalezený přes WaitForChild. Během hry nic nemění. Ostatní skripty v tomto návodu to dělají stejně.

Jak fungují pravidla stacků s katalogem výše, kde se jablka stackují do 10:

  • Pokud přidáte 15 jablek hráči se stackem 7, tento stack se doplní do 10 a pak začne nový stack s 5.
  • Když dojdou sloty, add přidá, co se vešlo, a vrátí toto číslo. Volejte nejdřív spaceFor, když potřebujete všechno, nebo nic, jak to dělá sebrání v kroku 5.
  • remove funguje na principu všechno, nebo nic. Požadavek na 3 jablka u hráče, který má 2, nic neodebere a vrátí false, proto výsledek zkontrolujte, než něco dáte na oplátku.
  • Sloty nemají díry: když se slot vyprázdní, ostatní se posunou nahoru. Seznam se tak snáz posílá a ukládá. O slotech, které drží svou pozici, se píše v otázkách na konci.
Co mohou volat ostatní serverové skripty
FunkceVracíK čemu
add(player, itemId, amount)Kolik se přidaloSebrání, odměny, nákupy
remove(player, itemId, amount)true, pokud se odebralo všechnoPoužití, prodej, crafting
count(player, itemId)Součet přes všechny stackyZjistit, co hráč má
spaceFor(player, itemId)Kolik se ještě vejdeKontrola před přidáním na principu všechno, nebo nic
getEquipped, setEquippedId vybaveného předmětu nebo nilVybavení, v kroku 6
load, serialize, unloadKopie připravená k uložení (serialize)Načítání a ukládání, v kroku 4

Krok 4: načítejte a ukládejte každý inventář

Inventáře žijí v paměti serveru, takže zmizí, když hráč odejde. Tento skript načte sloty hráče z data store, když přijde, a zapíše je zpět, když odchází, když se server vypíná a každé tři minuty pro případ pádu serveru. Ukládá jen id předmětů a počty: data store neumí uchovávat Instance, například Tool.

Vložte Script do ServerScriptService a pojmenujte ho InventoryData:

Script v ServerScriptService s názvem 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

-- Ukládají se jen hráči, jejichž data se načetla. Po neúspěšném načtení
-- se ukládat nesmí, jinak prázdný inventář nahradí skutečný.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Jeden neúspěšný požadavek nesmí nikoho stát předměty, proto to zkusíme několikrát.
-- GetDataStore je také uvnitř pcall, takže relace ve Studiu bez přístupu k data
-- store dostane varování, místo aby se tento skript zastavil.
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 -- hráč odešel, zatímco jsme načítali
	end
	if ok then
		InventoryService.load(player, saved) -- saved je nil pro nového hráče
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Obvykle to znamená, že přístup Studia k API services je vypnutý. Hrajeme se
		-- startovními předměty, abychom mohli testovat, ale nikdy je neukládáme.
		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 -- data se nikdy nenačetla, není co bezpečně zapsat
	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)

-- Když se server vypíná, uložíme všechny, kdo tu ještě jsou, a počkáme na každé
-- probíhající uložení, včetně těch, které spustil PlayerRemoving
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Ukládáme všechny jednou za pár minut, aby pád serveru stál minuty, ne celou relaci
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Co skript dělá a proč:

  • Načtení s výchozími hodnotami. Nový hráč nemá uloženou hodnotu, takže GetAsync vrátí nil a dostane startovní předměty. Uložené sloty znovu projdou pravidly stacků, takže předmět smazaný z katalogu nebo zmenšený maximální stack načítání nerozbije. Všechno, co se už nevejde nebo jehož id v katalogu už není, se zahodí a další uložení to udělá trvalým, proto mějte v katalogu každé id, které hráči mohou mít.
  • Nikdy neukládat po neúspěšném načtení. Zapisují se jen hráči z canSave. Na živém serveru se hráč, jehož data se nenačetla ani po třech pokusech, požádá o nové připojení. Ve Studiu místo toho dostane neukládané startovní předměty, o pár sekund později kvůli opakovaným pokusům. Tak to bude, dokud place není publikovaný se zapnutým přístupem k API.
  • Ukládání při odchodu a při vypnutí. BindToClose uloží všechny, kdo jsou ještě na serveru, a počká na už probíhající uložení. Roblox dává navázaným funkcím až 30 sekund.
  • Nepřekračovat limity. Jeden zápis na hráče každé tři minuty plus jeden při odchodu je mnohem méně než standardní rozpočet serveru 60 zápisů za minutu plus 40 za každého hráče (podle dokumentace k 30. září 2026). Vzor klíče User_ pochází z doporučení Robloxu a předání user ID do SetAsync spojí data s tímto hráčem, což Roblox důrazně doporučuje kvůli zpracování žádostí o smazání dat.

Pro malou hru je to spolehlivý základ. Zámek relace, který zabrání hráči, jenž rychle změnil server, načíst data dřív, než je starý server uložil, a kdy použít UpdateAsync místo SetAsync, rozebírá tutoriál k DataStore.

Krok 5: rozdávejte předměty ze světa

Sebrání je nejjednodušší způsob, jak se předměty dostanou do inventáře: part s ProximityPrompt, který předmět přidá, když ho hráč použije. Skript poslouchá jeho událost Triggered na serveru, takže se předmět přidá tam, kde klient nemůže zasáhnout.

  1. Přidejte Part do Workspace, pojmenujte ho Apple a obarvěte načerveno. Zapněte Anchored a vypněte CanCollide, aby do něj nikdo nenarazil, dokud je neviditelný. Výzva ukazuje název partu.
  2. S vybraným partem posuňte okno Properties na část Attributes a klikněte na +. Přidejte ItemId typu string a klikněte na Save, pak nastavte hodnotu apple. Stejně přidejte Amount typu number s hodnotou 1.
  3. Vložte do partu Script, pojmenujte ho ItemPickup a vložte tento kód:
Script v partu Apple ve Workspace s názvem ItemPickup
-- Dejte tento Script dovnitř Part a dejte Part dva atributy:
-- ItemId (řetězec, například apple) a Amount (číslo, například 1).
local ServerScriptService = game:GetService("ServerScriptService")

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

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

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

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

local visibleTransparency = part.Transparency

prompt.Triggered:Connect(function(player: Player)
	if not prompt.Enabled then
		return -- někdo jiný ho právě sebral
	end
	-- Vzdálenost kontrolujeme na serveru, nevěříme požadavku
	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 -- není dost místa: předmět necháme na místě
	end
	InventoryService.add(player, itemId, amount)

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

Kopírujte part a rozmístěte víc předmětů. Měňte atributy a rozdávejte dřevo, další meč nebo stack jablek.

Roblox kontroluje vzdálenost pro Triggered, ale jeho návod k bezpečnosti stejně radí výzvy kontrolovat na serveru: podvodník může vyvolávat události výzvy, i když je Enabled false, a může si přitáhnout neukotvený part ke své postavě. Proto skript sám kontroluje Enabled i vzdálenost a proto je part ukotvený.

Jakýkoli jiný serverový skript rozdává předměty stejně. Po nákupu, questu nebo zabití připojte InventoryService přes require jako skripty výše a zavolejte InventoryService.add(player, "wood", 5). Když se předmět nesmí ztratit, zkontrolujte nejdřív spaceFor. Dalším zdrojem může být NPC: v návodu k dialogům s NPC odpověď spustí akci na serveru a tato akce může stejně zavolat InventoryService.add.

Krok 6: vybavení Toolu a použití předmětů

Dva RemoteEventy nesou jediné požadavky, které klient smí udělat. EquipItem dá kopii Toolu předmětu ze ServerStorage do Backpacku hráče (hotbar dole na obrazovce) a do jeho ruky a opakovaný požadavek ji odloží. UseItem odebere jeden kus použitelného předmětu a použije jeho efekt, tady léčení.

Vložte Script do ServerScriptService a pojmenujte ho InventoryActions:

Script v ServerScriptService s názvem 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 } = {}

-- Každý požadavek začíná tady. Klient může poslat cokoli a kdykoli, proto
-- kontrolujeme typ, že předmět existuje, že ho hráč má, a četnost.
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

-- Zničí Tool tohoto předmětu, ať je kopie kdekoli: hotbar, ruka nebo 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) -- jeden vybavený nástroj najednou

	local tool = template:Clone()
	tool.CanBeDropped = false -- zahozenou kopii by mohl sebrat někdo jiný
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Druhá kopie ve StarterGear se po respawnu zkopíruje zpět do Backpacku
	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) -- rovnou do ruky
	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) -- opakované kliknutí na vybavený předmět ho odloží
	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 -- mrtvý nebo už s plným zdravím: předmět neplýtváme
	end
	-- Nejdřív předmět vezmeme a léčíme, jen pokud se to povedlo
	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)
Co je každému požadavku dovoleno
PožadavekKlient pošleServer před akcí ověří
EquipItemId předmětuJe to řetězec, předmět existuje, hráč ho má, požadavky nepřicházejí častěji než čtyři za sekundu, předmět má toolName a Tool s tímto názvem leží v ServerStorage.ItemTools
UseItemId předmětuStejné kontroly typu, vlastnictví a četnosti, předmět má hodnotu heal, postava je živá a zraněná a jeden předmět se odebere dřív, než se přidá zdraví

Tři detaily zabrání tomu, aby se Tool zdvojil nebo ztratil. Kopie má CanBeDropped nastavené na false, protože zahozený Tool spadne do Workspace, kde si ho může vzít jiný hráč, zatímco originál zůstane v inventáři. Každá kopie nese atribut InventoryItem, takže při odložení lze najít a zničit každou kopii, ať je kdekoli. A pokud má hráč kontejner StarterGear, dá se do něj druhá kopie. Roblox kopíruje StarterGear do Backpacku při každém objevení postavy, takže vybavený meč se po respawnu vrátí.

Vybavený je vždy jen jeden Tool a vybavení se neukládá, takže hráč po novém připojení začíná s prázdným hotbarem. Pokud později přidáte prodej nebo zahazování, předmět odložte dřív, než jeho poslední kopie opustí inventář.

Zástupný meč můžete proměnit v meč, který opravdu bojuje: postavte Tool podle návodu k meči, nechte mu název Sword a dejte ho do ItemTools místo zástupného. Serverový skript z toho návodu bude kontrolovat každý zásah, ať hráč meč získal jakkoli.

Krok 7: nakreslete mřížku inventáře

LocalScript postaví celé okno v kódu, takže nic nemusíte rozmisťovat ručně. ScrollingFrame drží sloty, UIGridLayout uvnitř je rozkládá do řad a AutomaticCanvasSize zvětšuje posuvnou oblast, jak řady přibývají.

V Exploreru otevřete StarterPlayer, vložte LocalScript do StarterPlayerScripts a pojmenujte ho InventoryClient:

LocalScript v StarterPlayerScripts s názvem 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. Okno postavíme jednou. ResetOnSpawn = false ho zachová i po respawnech.
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 ho zvětší podle buněk
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. Jedna buňka na slot. Tohle jen kreslí, co poslal server; samotný
-- inventář se odsud nikdy nemění.
local function makeCell(index: number, slot: Slot?, equippedId: string?)
	local cell = Instance.new("TextButton")
	cell.LayoutOrder = index
	cell.Text = ""
	cell.AutoButtonColor = slot ~= nil
	cell.BackgroundColor3 = if slot then COLOURS.slot else COLOURS.empty
	addCorner(cell, 8)
	cell.Parent = grid
	if not slot then
		return -- prázdný 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()
		-- Žádáme, nepřikazujeme: server požadavek ověří a pošle výsledek
		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

-- Server tohle posílá po načtení a po každé změně
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Otevíráme a zavíráme tlačítkem nebo klávesou 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)

LocalScript ve StarterPlayerScripts se spustí jednou za relaci a ResetOnSpawn = false zachová ScreenGui při respawnu postavy, takže mřížka dál ukazuje poslední kopii, kterou poslal server.

Klient kreslí jednu buňku na každý slot, včetně prázdných, takže inventář na 20 slotů vždy vypadá jako 20 slotů. Každá aktualizace zničí staré buňky a postaví nové, což je jednoduché a hodí se pro pár desítek slotů. Pokud server pošle InventoryUpdated dřív, než se k němu tento skript připojil, Roblox zprávu zařadí do fronty a doručí ji, jakmile se handler připojí, takže první inventář se neztratí.

Chcete okno nakreslit ve Studiu? Postavte ScreenGui s jedním slotem jako šablonou a v makeCell ho Clone. Pro ikony nastavte předmětu v katalogu icon s obrázkem, který jste nahráli, a jeho buňka místo názvu ukáže obrázek.

Otestujte inventář

  1. Klikněte na Play. Otevřete inventář tlačítkem vlevo nebo klávesou B: nový hráč má Sword a 3 Apple a počítadlo ukazuje 2 / 20 slots. Dokud Studio nemůže přistupovat k data store, předměty se objeví za pár sekund, po varováních o načítání v Output, a neukládají se.
  2. Klikněte na Sword. Meč se objeví v ruce a v hotbaru a jeho slot dostane fialový rámeček. Klikněte znovu a odložíte ho.
  3. Přijděte k partu Apple a použijte jeho výzvu. Stack jablek naroste na 4 a part na 15 sekund zmizí.
  4. Chcete-li otestovat léčení, nejdřív snižte zdraví. Přepněte Client/Server na Server, vyberte v Exploreru Humanoid své postavy, nastavte Health na 50, přepněte zpět na Client a klikněte na Apple.
  5. Se zapnutým přístupem Studia k API services hru zastavte a spusťte znovu. Sebrané jablko je na místě. Pokud se načtení nebo uložení nepovedlo, Output to řekne.

Chcete-li testovat s více hráči, vyberte v nastavení testu Server & Clients se 2 klienty. Každý hráč vidí jen svůj inventář a meč v ruce toho druhého vidí oba.

Časté chyby a řešení

Většina problémů je vidět v okně Output jako varování nebo červený řádek s chybou. Čtěte ten první: další chyby z něj často vyplývají.

Infinite yield possible u volání WaitForChild

Skript čeká na objekt, který pod přesně takovým názvem neexistuje. Porovnejte svůj Explorer se stromem z kroku 1: InventoryRemotes se třemi RemoteEventy v ReplicatedStorage, ItemTools ve ServerStorage a dva moduly. Názvy rozlišují velikost písmen. Návod k chybám ve skriptech toto varování rozebírá podrobněji.

Mřížka se otevře, ale zůstane prázdná

Klient kreslí jen to, co pošle server. Hledejte v Output varování Inventory load failed a ověřte, že InventoryData je Script, ne LocalScript, v ServerScriptService a vedle leží ModuleScript InventoryService. Pokud Output ukazuje chybu Remote event invocation, na klientu nikdo neposlouchá InventoryUpdated: hledejte dřívější chybu od InventoryClient.

Předměty se vynulují pokaždé, když hraju ve Studiu

Pokud Output píše Inventory not loaded: playing with starter items that will not be saved, place není publikovaný nebo je přístup Studia k API services vypnutý. Zapněte ho, jak popisuje krok 4, v testovací kopii své hry.

Kliknutí na meč nic nedělá

Hledejte v Output Cannot equip sword: Tool v ServerStorage.ItemTools se musí jmenovat přesně jako toolName v katalogu. Tool také potřebuje part s názvem Handle, aby se dal držet, pokud jste mu nenastavili RequiresHandle na false.

Výzva k sebrání se objeví, ale nic se nepřidá

Atribut ItemId musí přesně odpovídat id z katalogu, včetně velikosti písmen: apple, ne Apple. Nic se nepřidá, dokud se inventář hráče ještě načítá nebo když není místo na celý počet.

Ukládání se rozbije poté, co jsem změnil, co se ukládá

Data store přijímají jednoduchá data: řetězce, čísla, booleovské hodnoty a tabulky z nich. Uložení Toolu, Partu nebo jakékoli jiné Instance selže, nebo se hodnota uloží jako nil. Ukládejte id předmětu a počet a všechno ostatní obnovujte z katalogu, jak to dělá serialize.

Udělat s RoCode

Pokud je pro vás jednodušší systém popsat než ho stavět ručně, RoCode ho může postavit ve vašem otevřeném place. Je to AI agent pro Roblox Studio: funkci popíšete ve webovém chatu a jeho plugin pro Studio vytvoří skripty a objekty ve vašem Exploreru, místo aby vám dal kód k vložení.

Napíšete

Přidej inventář na 20 slotů se stacky předmětů, mřížku UI, která se otevírá na B, meč ze ServerStorage, který si hráči mohou vybavit, jablka, která léčí, a ukládání přes DataStoreService.

RoCode udělá
  • Může si prohlédnout váš place, když to krok potřebuje, přes Search Game a Search Scripts, aby navázal na předměty, remoty nebo kód ukládání, které už máte, a nepřidával druhý systém
  • Vytvoří složky a RemoteEvent přes Create Instance a ModuleScript, Script a LocalScript přes Create Script
  • Umí postavit kostru okna přes Build UI, kde je rozvržení inventáře se zástupnými sloty; kód, který sloty plní ze serveru, se píše samostatnými skripty
  • Ověří kompilaci každého skriptu ve Studiu přes Check Script, který chytá chyby kompilace a několik rizikových vzorů, ale nekontroluje typy, nedělá lint a váš kód nespouští

Každá dávka změn je bod pro vrácení ve Studiu. RoCode nemůže zapnout přístup Studia k API services, to uděláte sami. S pluginem 3.9 nebo novějším může spustit krátký playtest a přečíst chyby a s pluginem 3.9.15 nebo novějším jeho testovací postava umí mačkat klávesy a vybavovat předměty, ale kontroluje jen to, co se sám rozhodl otestovat, proto ukládání ověřte playtestem sami. Inventář stojí nad dalšími systémy, jako je ukládání a nástroje, a AI tvůrce her, který staví ve vašem vlastním place ve Studiu, je přidává po jednom promptu. Jak se RoCode připojuje ke Studiu.

Časté otázky

Použít Backpack v Robloxu místo vlastního inventáře?

Backpack je vestavěný inventář Robloxu: každý Tool v něm se zobrazí jako tlačítko v hotbaru. Pokud jsou všechny předměty ve vaší hře Tool a nepotřebujete stacky, počty ani limit slotů, může stačit, i když ukládat, které Tool každý hráč má, budete muset stejně. Vlastní inventář je potřeba pro předměty, které nejsou Tool, například materiály a spotřební předměty. Tento návod používá obojí: inventář drží všechno a Backpack drží vybavený Tool.

Jak v Robloxu skrýt standardní hotbar?

Z LocalScriptu zavolejte StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Když je hotbar skrytý, hráči potřebují jiný způsob, jak vybavený Tool vzít a odložit, například tlačítko, které požádá server, aby zavolal Humanoid:EquipTool nebo Humanoid:UnequipTools.

Jak udělat, aby sloty držely pozici kvůli drag and drop?

Uchovávejte seznam pevné délky s jedním záznamem na slot a prázdné sloty označujte hodnotou jako prázdné id, ne nil, protože Roblox nedoporučuje posílat tabulky s nil přes RemoteEvent. Pak přidejte RemoteEvent MoveItem, který pošle dvě čísla slotů, a ať server ověří, že obě jsou celá čísla od 1 do kapacity, než je prohodí.

Jak velký může být uložený inventář?

Jedna hodnota v data store může zabrat až 4 194 304 znaků po serializaci (podle dokumentace k 30. září 2026). Seznam id a počtů zabere nepatrný zlomek. Velikost uložení zvětšuje text u každého předmětu, například vlastní názvy nebo dlouhé popisy ukládané u každého předmětu.

Jak nakupovat a prodávat předměty za mince?

Všechno dělejte na serveru. Při prodeji zavolejte InventoryService.remove a plaťte, jen pokud vrátil true. Při nákupu zkontrolujte cenu a spaceFor, vezměte mince a pak zavolejte add. Návod k obchodu staví stranu nákupu.

Zdroje a další čtení

Jak byl kód ověřen: každý skript na této stránce prochází přísnou kontrolou typů Luau s definicemi Roblox API (luau-lsp, 20. listopadu 2026). Kontrola typů zachytí chyby v názvech API a špatné typy, ale ne chyby v herní logice, proto vše otestujte ve Studiu před publikováním.

Vyzkoušejte RoCode ve své hře.

Kredity zdarma každý den, bez karty. Nainstalujte plugin, popište funkci a podívejte se, co se objeví ve Studiu.