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
Jak je inventář postavený
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ě.
| Část | Typ a místo | Úkol |
|---|---|---|
ItemCatalog | ModuleScript v ReplicatedStorage | Co 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. |
InventoryService | ModuleScript v ServerScriptService | Drží sloty všech hráčů. Jediný kód, který přidává, odebírá a skládá předměty do stacků. |
InventoryData | Script v ServerScriptService | Načte předměty hráče při vstupu a ukládá je. |
InventoryActions | Script v ServerScriptService | Ověřuje a provádí požadavky na vybavení a použití. |
ItemPickup | Script uvnitř Part | Dá předmět tomu, kdo ho sebral. |
InventoryClient | LocalScript ve StarterPlayerScripts | Kreslí 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.
- Do ReplicatedStorage vložte Folder s názvem
InventoryRemotes. Dovnitř vložte tři RemoteEvent s názvyInventoryUpdated,EquipItemaUseItem. - Do ServerStorage vložte Folder s názvem
ItemTools. Dovnitř vložte Tool s názvemSworda do Toolu Part s názvemHandle(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. - Skripty přidávejte postupně podle kroků. Strom ukazuje, kam každý z nich patří.
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:
-- 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:
-- 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,
addpřidá, co se vešlo, a vrátí toto číslo. Volejte nejdřívspaceFor, když potřebujete všechno, nebo nic, jak to dělá sebrání v kroku 5. removefunguje 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.
| Funkce | Vrací | K čemu |
|---|---|---|
add(player, itemId, amount) | Kolik se přidalo | Sebrání, odměny, nákupy |
remove(player, itemId, amount) | true, pokud se odebralo všechno | Použití, prodej, crafting |
count(player, itemId) | Součet přes všechny stacky | Zjistit, co hráč má |
spaceFor(player, itemId) | Kolik se ještě vejde | Kontrola před přidáním na principu všechno, nebo nic |
getEquipped, setEquipped | Id vybaveného předmětu nebo nil | Vybavení, v kroku 6 |
load, serialize, unload | Kopie 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:
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
GetAsyncvrá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í.
BindToCloseuloží 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 doSetAsyncspojí 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.
- Přidejte Part do Workspace, pojmenujte ho
Applea 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. - S vybraným partem posuňte okno Properties na část Attributes a klikněte na +. Přidejte
ItemIdtypu string a klikněte na Save, pak nastavte hodnotuapple. Stejně přidejteAmounttypu number s hodnotou1. - Vložte do partu Script, pojmenujte ho
ItemPickupa vložte tento kód:
-- 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:
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)
| Požadavek | Klient pošle | Server před akcí ověří |
|---|---|---|
EquipItem | Id předmětu | Je 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 |
UseItem | Id předmětu | Stejné 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:
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ář
- 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.
- 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.
- Přijděte k partu Apple a použijte jeho výzvu. Stack jablek naroste na 4 a part na 15 sekund zmizí.
- Chcete-li otestovat léčení, nejdřív snižte zdraví. Přepněte Client/Server na Server, vyberte v Exploreru
Humanoidsvé postavy, nastavte Health na 50, přepněte zpět na Client a klikněte na Apple. - 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í.
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.
- 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í
- Roblox Creator Docs: Remote events and callbacks (anglicky). FireClient, OnServerEvent, omezení argumentů a jak se zprávy bez příjemce řadí do fronty
- Roblox Creator Docs: Securing the client-server boundary (anglicky). kontrola vstupů remotů, kontroly ProximityPrompt a podvržení dat v data store
- Roblox Creator Docs: Data stores (anglicky). GetAsync, SetAsync a zapnutí přístupu ze Studia
- Roblox Creator Docs: Best practices for data stores (anglicky). jeden klíč na hráče, vzory klíčů a pravidelná ukládání
- Roblox Creator Docs: Data store error codes and limits (anglicky). limity požadavků na server a limit velikosti jedné hodnoty
- Roblox Creator Docs: In-game tools (anglicky). Handle, ukotvení, Backpack a StarterGear
- Roblox Creator Docs: Grid and table layouts (anglicky). velikost buněk UIGridLayout, odsazení a pořadí řazení
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.