Návod · Herné systémy

Ako urobiť inventár v Roblox Studiu

Inventár vyzerá ako úloha pre rozhranie, ale to, či sa dá hacknúť a či stráca predmety, rozhoduje miesto, kde sú predmety uložené. V tomto návode ležia predmety každého hráča v tabuľke na serveri, každý hráč dostane kópiu a vykreslí ju ako mriežku, vybavuje Tool a používa spotrebné predmety cez požiadavky, ktoré kontroluje server, a všetko sa ukladá do data store.

Aktualizované 20. novembra 202614 min čítaniaAutor:

V skratke

Predmety každého hráča držte v tabuľke na serveri, vnútri ModuleScriptu v ServerScriptService, a len tento kód ich smie pridávať, odoberať a skladať do stackov. Predmety opíšte raz v ModuleScripte v ReplicatedStorage (id, názov, maximálny stack). Po každej zmene server pošle tomuto hráčovi RemoteEvent s kópiou jeho inventára a LocalScript ju vykreslí ako mriežku cez ScrollingFrame a UIGridLayout.

  • Klient nikdy nepridáva predmety. Môže len požiadať, napríklad "vybav môj meč", a server overí, že ho hráč má, skôr než čokoľvek urobí.
  • Predmety sa objavujú len cez serverový kód, ktorý ovládate: zobratie, nákupy v obchode po kontrole na serveri, odmeny.
  • Ukladajte id predmetov a ich počty, nie Tool, cez DataStoreService, keď hráč odchádza, keď sa server vypína a raz za pár minút. Nikdy neukladajte hráča, ktorého dáta sa nenačítali.
Na tejto stránke
  1. Ako je postavený
  2. Prečo predmety na serveri
  3. 1. Príprava Explorera
  4. 2. Katalóg predmetov
  5. 3. Inventár na serveri
  6. 4. Načítanie a ukladanie
  7. 5. Zbieranie predmetov
  8. 6. Vybavenie a použitie
  9. 7. Mriežka UI
  10. Test
  11. Common errors
  12. S RoCode
  13. Časté otázky
  14. Zdroje a ďalšie čítanie

Ako je inventár postavený

IlustráciaStlačte B, prejdite myšou na predmet a prečítajte si opis, kliknite na Sword a vezmete ho do ruky.

Systém sa skladá zo šiestich malých častí a každá má jednu úlohu. Všetky pravidlá o predmetoch žijú v jednom serverovom module, takže keď sa niečo pokazí, hľadáte presne na jednom mieste.

Časti systému a kde bežia
ČasťTyp a miestoÚloha
ItemCatalogModuleScript v ReplicatedStorageČo je každý predmet: názov, opis, maximálny stack a či sa dá vybaviť alebo použiť. Číta ho server aj všetci klienti.
InventoryServiceModuleScript v ServerScriptServiceDrží sloty všetkých hráčov. Jediný kód, ktorý pridáva, odoberá a skladá predmety do stackov.
InventoryDataScript v ServerScriptServiceNačíta predmety hráča pri vstupe a ukladá ich.
InventoryActionsScript v ServerScriptServiceOveruje a vykonáva požiadavky na vybavenie a použitie.
ItemPickupScript vnútri PartDá predmet tomu, kto ho zobral.
InventoryClientLocalScript v StarterPlayerScriptsKreslí mriežku a posiela požiadavky. Sám nič nemení.

Dáta tečú jedným smerom. Server zmení inventár, potom tomuto hráčovi pošle InventoryUpdated s celým inventárom a klient ho prekreslí. Keď hráč klikne na slot, klient pošle EquipItem alebo UseItem s id predmetu; server požiadavku overí, vykoná zmenu a nová kópia príde rovnakou cestou. Posielať celý inventár je jednoduchšie ako posielať zmeny a pre pár desiatok slotov zostáva správa malá.

Prečo klient nikdy nepridáva predmety

Láka pridať predmet priamo v LocalScripte, ktorý ho zobrazuje: hráč klikol, slot sa zaplnil. To sa pokazí dvoma spôsobmi.

  • Nikto iný to nevidí. Zmena v LocalScripte existuje len na zariadení tohto hráča. Server sa o nej nedozvie, takže sa neuloží a žiadny serverový skript ju nemôže použiť.
  • Podvrhnúť to môže ktokoľvek. Ak to opravíte remotom ako AddItem(itemId, amount), podvodník bude môcť túto udalosť volať sám, s ľubovoľnými argumentmi a koľkokrát chce. Návod Robloxu k bezpečnosti hovorí, že server musí overiť všetko, čo klient pošle, skôr než to použije.

Preto v tomto návode klient môže len žiadať, aby sa niečo urobilo s predmetmi, ktoré hráč už má: "vybav toto" a "použi toto". Každá požiadavka nesie jedno id predmetu a žiadne počty a na serveri prejde jednou kontrolou: je to reťazec, taký predmet existuje, hráč má aspoň jeden a neposiela viac ako štyri požiadavky za sekundu. Potom server sám nájde Tool podľa katalógu. Nikdy od klienta neprijme Tool, cestu ani inštanciu, pred čím varuje ten istý návod.

Predmety sa do inventára dostanú len cez serverový kód: zobratie, ktoré overil server, nákup, za ktorý server strhol peniaze (stavia ho návod na obchod), odmenu za quest alebo drop. O remotoch všeobecne, s kontrolou ďalších druhov argumentov, si prečítajte v návode na RemoteEvent.

Krok 1: pripravte Explorer

Vytvorte tieto objekty ručne. Skripty z ďalších krokov ich hľadajú podľa názvu, preto každý názov píšte presne ako tu.

  1. Do ReplicatedStorage vložte Folder s názvom InventoryRemotes. Dovnútra vložte tri RemoteEvent s názvami InventoryUpdated, EquipItem a UseItem.
  2. Do ServerStorage vložte Folder s názvom ItemTools. Dovnútra vložte Tool s názvom Sword a do Toolu Part s názvom Handle (1 na 4 na 1 stud úplne stačí). Overte, že pri Handle nie je zaškrtnuté Anchored: Roblox varuje, že postava uviazne na mieste, keď drží nástroj s ukotvenými partmi. Poslúži aj Tool, ktorý už máte, ak jeho názov zodpovedá katalógu z kroku 2.
  3. Skripty pridávajte postupne podľa krokov. Strom ukazuje, kam každý z nich patrí.
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: opíšte predmety v katalógu

Katalóg opíše každý predmet, ktorý môže existovať, raz. Inventáre potom uchovávajú len id predmetu a počet. Uloženia tak zostávajú malé a neskôr môžete predmet premenovať alebo prepísať jeho opis bez toho, aby ste siahli na niečie uložené dáta.

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

ModuleScript v ReplicatedStorage s názvom ItemCatalog
-- Všetky predmety, ktoré môžu v hre existovať. Tento zoznam číta server aj všetci
-- klienti; len server rozhoduje, kto čo má.
export type Item = {
	id: string, -- musí zodpovedať kľúču nižšie
	name: string,
	description: string,
	maxStack: number, -- koľko tohto predmetu sa zmestí do jedného slotu
	icon: string?, -- voliteľný obrázok: "rbxassetid://" plus ID vášho obrázka
	toolName: string?, -- Tool v ServerStorage.ItemTools: predmet sa dá vybaviť
	heal: number?, -- koľko zdravia obnoví: predmet je spotrebný
}

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áti predmet s týmto id, alebo nil, ak taký predmet nie je
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Voliteľné polia rozhodujú, čo predmet robí. toolName ho urobí vybaviteľným, heal použiteľným a predmet bez oboch polí, ako drevo, leží v inventári, kým ho neodoberie iný serverový kód (crafting, predaj).

Ak chcete pridať predmet, pridajte záznam, ktorého kľúč a id sa zhodujú. Id rozlišujú veľkosť písmen a práve ony sa ukladajú, preto id nikdy nemeňte, keď predmet už hráči majú: meňte jeho name.

Krok 3: držte inventáre na serveri

Tento ModuleScript vlastní inventár každého hráča. Každý inventár je zoznam slotov, v každom slote id predmetu a počet, plus kapacita 20 slotov. Ostatné serverové skripty volajú jeho funkcie a nikto iný tabuľku neupravuje.

Vložte ModuleScript do ServerScriptService a pomenujte ho InventoryService:

ModuleScript v ServerScriptService s názvom InventoryService
-- Jediný kód, ktorý mení inventáre. Leží v ServerScriptService,
-- kde ho klienti nemôžu vidieť ani spustiť.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Strict režim nevidí, čo vracia require cez WaitForChild, preto
-- opisujeme tú časť modulu, ktorú tento skript používa
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 -- slotov na hráča
local STARTER_ITEMS: { Slot } = { -- s čím začína úplne nový hráč
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Pošle majiteľovi kópiu jeho inventára. Volá sa po každej zmene.
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

-- Pravidlá stackov: najprv doplníme neplné stacky, potom začneme nové stacky
-- v prázdnych slotoch. Vráti, koľko sa pridalo, môže to byť menej, než sa žiadalo.
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

-- Koľko predmetu sa ešte zmestí: miesto v jeho stackoch plus prázdne 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

-- Pridá až amount kusov predmetu. Vráti, koľko sa pridalo (0, ak
-- predmet neexistuje, inventár je plný alebo sa ešte nenačítal).
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

-- Odoberie presne amount kusov predmetu, počnúc poslednými stackmi.
-- Ak ich hráč má menej, nič neodoberie a vráti 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
	-- Ideme od konca, aby table.remove nepreskakoval 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á sa, keď sa uložené dáta hráča načítali. saved je to, čo
-- vrátil data store: nil pre nového hráča. Každý záznam znova prejde
-- pravidlami stackov, takže zmazané predmety a staré veľkosti stackov nič nepokazia.
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á kópia na uloženie, alebo nil, ak sa dáta hráča nikdy nenačítali
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

Riadky type a pretypovanie :: po require potrebuje len typová kontrola Luau, ktorá nevidí, čo vracia modul nájdený cez WaitForChild. Počas hry nič nemenia. Ostatné skripty v tomto návode to robia rovnako.

Ako fungujú pravidlá stackov s katalógom vyššie, kde sa jablká stackujú do 10:

  • Ak pridáte 15 jabĺk hráčovi so stackom 7, tento stack sa doplní do 10 a potom začne nový stack s 5.
  • Keď dôjdu sloty, add pridá, čo sa zmestilo, a vráti toto číslo. Volajte najprv spaceFor, keď potrebujete všetko alebo nič, ako to robí zobratie v kroku 5.
  • remove funguje na princípe všetko alebo nič. Požiadavka na 3 jablká pri hráčovi, ktorý má 2, nič neodoberie a vráti false, preto výsledok skontrolujte, skôr než niečo dáte na oplátku.
  • Sloty nemajú diery: keď sa slot vyprázdni, ostatné sa posunú nahor. Zoznam sa tak ľahšie posiela a ukladá. O slotoch, ktoré držia svoju pozíciu, sa píše v otázkach na konci.
Čo môžu volať ostatné serverové skripty
FunkciaVraciaNa čo
add(player, itemId, amount)Koľko sa pridaloZobratia, odmeny, nákupy
remove(player, itemId, amount)true, ak sa odobralo všetkoPoužitie, predaj, crafting
count(player, itemId)Súčet cez všetky stackyZistiť, čo hráč má
spaceFor(player, itemId)Koľko sa ešte zmestíKontrola pred pridaním na princípe všetko alebo nič
getEquipped, setEquippedId vybaveného predmetu alebo nilVybavenie, v kroku 6
load, serialize, unloadKópia pripravená na uloženie (serialize)Načítanie a ukladanie, v kroku 4

Krok 4: načítajte a ukladajte každý inventár

Inventáre žijú v pamäti servera, takže zmiznú, keď hráč odíde. Tento skript načíta sloty hráča z data store, keď príde, a zapíše ich späť, keď odchádza, keď sa server vypína a každé tri minúty pre prípad pádu servera. Ukladá len id predmetov a počty: data store nevie uchovávať Instance, napríklad Tool.

Vložte Script do ServerScriptService a pomenujte ho InventoryData:

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

-- Ukladajú sa len hráči, ktorých dáta sa načítali. Po neúspešnom načítaní
-- sa ukladať nesmie, inak prázdny inventár nahradí skutočný.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Jedna neúspešná požiadavka nesmie nikoho stáť predmety, preto to skúsime niekoľkokrát.
-- GetDataStore je tiež vnútri pcall, takže relácia v Studiu bez prístupu k data
-- store dostane varovanie, namiesto toho, aby sa 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áč odišiel, kým sme načítavali
	end
	if ok then
		InventoryService.load(player, saved) -- saved je nil pre nového hráča
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Zvyčajne to znamená, že prístup Studia k API services je vypnutý. Hráme sa
		-- so štartovými predmetmi, aby sme mohli testovať, ale nikdy ich neukladá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 -- dáta sa nikdy nenačítali, nie je čo bezpečne zapísať
	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)

-- Keď sa server vypína, uložíme všetkých, ktorí sú tu ešte, a počkáme na každé
-- prebiehajúce uloženie, vrátane tých, ktoré spustil PlayerRemoving
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Ukladáme všetkých raz za pár minút, aby pád servera stál minúty, nie celú reláciu
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Čo skript robí a prečo:

  • Načítanie s predvolenými hodnotami. Nový hráč nemá uloženú hodnotu, takže GetAsync vráti nil a dostane štartové predmety. Uložené sloty znova prejdú pravidlami stackov, takže predmet zmazaný z katalógu alebo zmenšený maximálny stack načítanie nepokazí. Všetko, čo sa už nezmestí alebo ktorého id v katalógu už nie je, sa zahodí a ďalšie uloženie to urobí trvalým, preto majte v katalógu každé id, ktoré hráči môžu mať.
  • Nikdy neukladať po neúspešnom načítaní. Zapisujú sa len hráči z canSave. Na živom serveri sa hráč, ktorého dáta sa nenačítali ani po troch pokusoch, požiada o nové pripojenie. V Studiu namiesto toho dostane neukladané štartové predmety, o pár sekúnd neskôr kvôli opakovaným pokusom. Tak to bude, kým place nie je publikovaný so zapnutým prístupom k API.
  • Ukladanie pri odchode a pri vypnutí. BindToClose uloží všetkých, ktorí sú ešte na serveri, a počká na už prebiehajúce uloženia. Roblox dáva naviazaným funkciám až 30 sekúnd.
  • Neprekračovať limity. Jeden zápis na hráča každé tri minúty plus jeden pri odchode je oveľa menej ako štandardný rozpočet servera 60 zápisov za minútu plus 40 za každého hráča (podľa dokumentácie k 30. septembru 2026). Vzor kľúča User_ pochádza z odporúčaní Robloxu a odovzdanie user ID do SetAsync spojí dáta s týmto hráčom, čo Roblox dôrazne odporúča kvôli spracovaniu žiadostí o zmazanie dát.

Pre malú hru je to spoľahlivý základ. Zámok relácie, ktorý zabráni hráčovi, ktorý rýchlo zmenil server, načítať dáta skôr, než ich starý server uložil, a kedy použiť UpdateAsync namiesto SetAsync, rozoberá návod na DataStore.

Krok 5: rozdávajte predmety zo sveta

Zobratie je najjednoduchší spôsob, ako sa predmety dostanú do inventára: part s ProximityPrompt, ktorý predmet pridá, keď ho hráč použije. Skript počúva jeho udalosť Triggered na serveri, takže sa predmet pridá tam, kde klient nemôže zasiahnuť.

  1. Pridajte Part do Workspace, pomenujte ho Apple a zafarbite načerveno. Zapnite Anchored a vypnite CanCollide, aby doň nikto nenarazil, kým je neviditeľný. Výzva ukazuje názov partu.
  2. S vybraným partom posuňte okno Properties na časť Attributes a kliknite na +. Pridajte ItemId typu string a kliknite na Save, potom nastavte hodnotu apple. Rovnako pridajte Amount typu number s hodnotou 1.
  3. Vložte do partu Script, pomenujte ho ItemPickup a vložte tento kód:
Script v parte Apple vo Workspace s názvom ItemPickup
-- Dajte tento Script dovnútra Part a dajte Part dva atribúty:
-- ItemId (reťazec, napríklad apple) a Amount (číslo, naprí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 -- niekto iný ho práve zobral
	end
	-- Vzdialenosť kontrolujeme na serveri, neveríme požiadavke
	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 -- nie je dosť miesta: predmet necháme na mieste
	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 rozmiestnite viac predmetov. Meňte atribúty a rozdávajte drevo, ďalší meč alebo stack jabĺk.

Roblox kontroluje vzdialenosť pre Triggered, ale jeho návod k bezpečnosti aj tak radí výzvy kontrolovať na serveri: podvodník môže vyvolávať udalosti výzvy, aj keď je Enabled false, a môže si pritiahnuť neukotvený part k svojej postave. Preto skript sám kontroluje Enabled aj vzdialenosť a preto je part ukotvený.

Akýkoľvek iný serverový skript rozdáva predmety rovnako. Po nákupe, queste alebo zabití pripojte InventoryService cez require ako skripty vyššie a zavolajte InventoryService.add(player, "wood", 5). Keď sa predmet nesmie stratiť, skontrolujte najprv spaceFor. Ďalším zdrojom môže byť NPC: v návode na dialógy s NPC odpoveď spustí akciu na serveri a táto akcia môže rovnako zavolať InventoryService.add.

Krok 6: vybavenie Toolu a použitie predmetov

Dva RemoteEventy nesú jediné požiadavky, ktoré klient smie urobiť. EquipItem dá kópiu Toolu predmetu zo ServerStorage do Backpacku hráča (hotbar dole na obrazovke) a do jeho ruky a opakovaná požiadavka ju odloží. UseItem odoberie jeden kus použiteľného predmetu a použije jeho efekt, tu liečenie.

Vložte Script do ServerScriptService a pomenujte ho InventoryActions:

Script v ServerScriptService s názvom 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žiadavka začína tu. Klient môže poslať čokoľvek a kedykoľvek, preto
-- kontrolujeme typ, že predmet existuje, že ho hráč má, a frekvenciu.
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 tohto predmetu, nech je kópia kdekoľvek: hotbar, ruka alebo 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 naraz

	local tool = template:Clone()
	tool.CanBeDropped = false -- zahodenú kópiu by mohol zobrať niekto iný
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Druhá kópia v StarterGear sa po respawne skopíruje späť 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) -- rovno 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é kliknutie na vybavený predmet 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 -- mŕtvy alebo už s plným zdravím: predmet neplytváme
	end
	-- Najprv predmet vezmeme a liečime, len ak sa to podarilo
	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)
Čo je každej požiadavke dovolené
PožiadavkaKlient pošleServer pred akciou overí
EquipItemId predmetuJe to reťazec, predmet existuje, hráč ho má, požiadavky neprichádzajú častejšie ako štyri za sekundu, predmet má toolName a Tool s týmto názvom leží v ServerStorage.ItemTools
UseItemId predmetuRovnaké kontroly typu, vlastníctva a frekvencie, predmet má hodnotu heal, postava je živá a zranená a jeden predmet sa odoberie skôr, než sa pridá zdravie

Tri detaily zabránia tomu, aby sa Tool zdvojil alebo stratil. Kópia má CanBeDropped nastavené na false, pretože zahodený Tool spadne do Workspace, kde si ho môže vziať iný hráč, zatiaľ čo originál zostane v inventári. Každá kópia nesie atribút InventoryItem, takže pri odložení sa dá nájsť a zničiť každá kópia, nech je kdekoľvek. A ak má hráč kontajner StarterGear, dá sa doň druhá kópia. Roblox kopíruje StarterGear do Backpacku pri každom objavení postavy, takže vybavený meč sa po respawne vráti.

Vybavený je vždy len jeden Tool a vybavenie sa neukladá, takže hráč po novom pripojení začína s prázdnym hotbarom. Ak neskôr pridáte predaj alebo zahadzovanie, predmet odložte skôr, než jeho posledná kópia opustí inventár.

Zástupný meč môžete premeniť na meč, ktorý naozaj bojuje: postavte Tool podľa návodu na meč, nechajte mu názov Sword a dajte ho do ItemTools namiesto zástupného. Serverový skript z toho návodu bude kontrolovať každý zásah, nech hráč meč získal akokoľvek.

Krok 7: nakreslite mriežku inventára

LocalScript postaví celé okno v kóde, takže nič nemusíte rozmiestňovať ručne. ScrollingFrame drží sloty, UIGridLayout vnútri ich rozkladá do radov a AutomaticCanvasSize zväčšuje posuvnú oblasť, ako rady pribúdajú.

V Exploreri otvorte StarterPlayer, vložte LocalScript do StarterPlayerScripts a pomenujte ho InventoryClient:

LocalScript v StarterPlayerScripts s názvom 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 raz. ResetOnSpawn = false ho zachová aj po respawnoch.
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äčší podľa buniek
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 bunka na slot. Toto len kreslí, čo poslal server; samotný
-- inventár sa odtiaľto nikdy nemení.
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ázdny 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()
		-- Žiadame, neprikazujeme: server požiadavku overí a pošle výsledok
		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 toto posiela po načítaní a po každej zmene
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Otvárame a zatvárame tlačidlom alebo klávesom 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 v StarterPlayerScripts sa spustí raz za reláciu a ResetOnSpawn = false zachová ScreenGui pri respawne postavy, takže mriežka ďalej ukazuje poslednú kópiu, ktorú poslal server.

Klient kreslí jednu bunku na každý slot, vrátane prázdnych, takže inventár na 20 slotov vždy vyzerá ako 20 slotov. Každá aktualizácia zničí staré bunky a postaví nové, čo je jednoduché a hodí sa pre pár desiatok slotov. Ak server pošle InventoryUpdated skôr, než sa k nemu tento skript pripojil, Roblox správu zaradí do frontu a doručí ju, keď sa handler pripojí, takže prvý inventár sa nestratí.

Chcete okno nakresliť v Studiu? Postavte ScreenGui s jedným slotom ako šablónou a v makeCell ho Clone. Pre ikony nastavte predmetu v katalógu icon s obrázkom, ktorý ste nahrali, a jeho bunka namiesto názvu ukáže obrázok.

Otestujte inventár

  1. Kliknite na Play. Otvorte inventár tlačidlom vľavo alebo klávesom B: nový hráč má Sword a 3 Apple a počítadlo ukazuje 2 / 20 slots. Kým Studio nemôže pristupovať k data store, predmety sa objavia o pár sekúnd, po varovaniach o načítavaní v Output, a neukladajú sa.
  2. Kliknite na Sword. Meč sa objaví v ruke a v hotbare a jeho slot dostane fialový rámik. Kliknite znova a odložíte ho.
  3. Prídite k partu Apple a použite jeho výzvu. Stack jabĺk narastie na 4 a part na 15 sekúnd zmizne.
  4. Ak chcete otestovať liečenie, najprv znížte zdravie. Prepnite Client/Server na Server, vyberte v Exploreri Humanoid svojej postavy, nastavte Health na 50, prepnite späť na Client a kliknite na Apple.
  5. So zapnutým prístupom Studia k API services hru zastavte a spustite znova. Zobraté jablko je na mieste. Ak sa načítanie alebo uloženie nepodarilo, Output to povie.

Ak chcete testovať s viacerými hráčmi, vyberte v nastaveniach testu Server & Clients s 2 klientmi. Každý hráč vidí len svoj inventár a meč v ruke toho druhého vidia obaja.

Časté chyby a riešenia

Väčšina problémov je viditeľná v okne Output ako varovanie alebo červený riadok s chybou. Čítajte ten prvý: ďalšie chyby z neho často vyplývajú.

Infinite yield possible pri volaní WaitForChild

Skript čaká na objekt, ktorý pod presne takým názvom neexistuje. Porovnajte svoj Explorer so stromom z kroku 1: InventoryRemotes s tromi RemoteEventmi v ReplicatedStorage, ItemTools v ServerStorage a dva moduly. Názvy rozlišujú veľkosť písmen. Návod na chyby v skriptoch toto varovanie rozoberá podrobnejšie.

Mriežka sa otvorí, ale zostane prázdna

Klient kreslí len to, čo pošle server. Hľadajte v Output varovanie Inventory load failed a overte, že InventoryData je Script, nie LocalScript, v ServerScriptService a vedľa leží ModuleScript InventoryService. Ak Output ukazuje chybu Remote event invocation, na klientovi nikto nepočúva InventoryUpdated: hľadajte skoršiu chybu od InventoryClient.

Predmety sa vynulujú zakaždým, keď hrám v Studiu

Ak Output píše Inventory not loaded: playing with starter items that will not be saved, place nie je publikovaný alebo je prístup Studia k API services vypnutý. Zapnite ho, ako opisuje krok 4, v testovacej kópii svojej hry.

Kliknutie na meč nič nerobí

Hľadajte v Output Cannot equip sword: Tool v ServerStorage.ItemTools sa musí volať presne ako toolName v katalógu. Tool tiež potrebuje part s názvom Handle, aby sa dal držať, ak ste mu nenastavili RequiresHandle na false.

Výzva na zobratie sa objaví, ale nič sa nepridá

Atribút ItemId musí presne zodpovedať id z katalógu, vrátane veľkosti písmen: apple, nie Apple. Nič sa nepridá, kým sa inventár hráča ešte načítava alebo keď nie je miesto na celý počet.

Ukladanie sa pokazí potom, čo som zmenil, čo sa ukladá

Data store prijímajú jednoduché dáta: reťazce, čísla, booleovské hodnoty a tabuľky z nich. Uloženie Toolu, Partu alebo akejkoľvek inej Instance zlyhá, alebo sa hodnota uloží ako nil. Ukladajte id predmetu a počet a všetko ostatné obnovujte z katalógu, ako to robí serialize.

Urobiť s RoCode

Ak je pre vás jednoduchšie systém opísať ako ho stavať ručne, RoCode ho môže postaviť vo vašom otvorenom place. Je to AI agent pre Roblox Studio: funkciu opíšete vo webovom chate a jeho plugin pre Studio vytvorí skripty a objekty vo vašom Exploreri, namiesto toho, aby vám dal kód na vloženie.

Napíšete

Pridaj inventár na 20 slotov so stackmi predmetov, mriežku UI, ktorá sa otvára na B, meč zo ServerStorage, ktorý si hráči môžu vybaviť, jablká, ktoré liečia, a ukladanie cez DataStoreService.

RoCode urobí
  • Môže si prezrieť váš place, keď to krok potrebuje, cez Search Game a Search Scripts, aby nadviazal na predmety, remoty alebo kód ukladania, ktoré už máte, a nepridával druhý systém
  • Vytvorí priečinky a RemoteEvent cez Create Instance a ModuleScript, Script a LocalScript cez Create Script
  • Vie postaviť kostru okna cez Build UI, kde je rozloženie inventára so zástupnými slotmi; kód, ktorý sloty plní zo servera, sa píše samostatnými skriptmi
  • Overí kompiláciu každého skriptu v Studiu cez Check Script, ktorý chytá chyby kompilácie a niekoľko rizikových vzorov, ale nekontroluje typy, nerobí lint a váš kód nespúšťa

Každá dávka zmien je bod na vrátenie v Studiu. RoCode nemôže zapnúť prístup Studia k API services, to urobíte sami. S pluginom 3.9 alebo novším môže spustiť krátky playtest a prečítať chyby a s pluginom 3.9.15 alebo novším jeho testovacia postava vie stláčať klávesy a vybavovať predmety, ale kontroluje len to, čo sa sám rozhodol otestovať, preto ukladanie overte playtestom sami. Inventár stojí nad ďalšími systémami, ako je ukladanie a nástroje, a AI tvorca hier, ktorý stavia vo vašom vlastnom place v Studiu, ich pridáva po jednom prompte. Ako sa RoCode pripája k Studiu.

Časté otázky

Použiť Backpack v Robloxe namiesto vlastného inventára?

Backpack je vstavaný inventár Robloxu: každý Tool v ňom sa zobrazí ako tlačidlo v hotbare. Ak sú všetky predmety vo vašej hre Tool a nepotrebujete stacky, počty ani limit slotov, môže stačiť, hoci ukladať, ktoré Tool každý hráč má, budete musieť aj tak. Vlastný inventár je potrebný pre predmety, ktoré nie sú Tool, napríklad materiály a spotrebné predmety. Tento návod používa oboje: inventár drží všetko a Backpack drží vybavený Tool.

Ako v Robloxe skryť štandardný hotbar?

Z LocalScriptu zavolajte StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Keď je hotbar skrytý, hráči potrebujú iný spôsob, ako vybavený Tool vziať a odložiť, napríklad tlačidlo, ktoré požiada server, aby zavolal Humanoid:EquipTool alebo Humanoid:UnequipTools.

Ako urobiť, aby sloty držali pozíciu kvôli drag and drop?

Uchovávajte zoznam pevnej dĺžky s jedným záznamom na slot a prázdne sloty označujte hodnotou ako prázdne id, nie nil, pretože Roblox neodporúča posielať tabuľky s nil cez RemoteEvent. Potom pridajte RemoteEvent MoveItem, ktorý pošle dve čísla slotov, a nech server overí, že obe sú celé čísla od 1 do kapacity, skôr než ich vymení.

Aký veľký môže byť uložený inventár?

Jedna hodnota v data store môže zabrať až 4 194 304 znakov po serializácii (podľa dokumentácie k 30. septembru 2026). Zoznam id a počtov zaberie nepatrný zlomok. Veľkosť uloženia zväčšuje text pri každom predmete, napríklad vlastné názvy alebo dlhé opisy ukladané pri každom predmete.

Ako kupovať a predávať predmety za mince?

Všetko robte na serveri. Pri predaji zavolajte InventoryService.remove a plaťte, len ak vrátil true. Pri nákupe skontrolujte cenu a spaceFor, vezmite mince a potom zavolajte add. Návod na obchod stavia stranu nákupu.

Zdroje a ďalšie čítanie

Ako bol kód overený: každý skript na tejto stránke prechádza prísnou kontrolou typov Luau s definíciami Roblox API (luau-lsp, 20. novembra 2026). Kontrola typov zachytí chyby v názvoch API a nesprávne typy, ale nie chyby v hernej logike, preto všetko pred publikovaním otestujte v Studiu.

Vyskúšajte RoCode vo svojej hre.

Kredity zadarmo každý deň, bez karty. Nainštalujte plugin, opíšte funkciu a pozrite sa, čo sa objaví v Studiu.