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
Ako je inventár postavený
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.
| Časť | Typ a miesto | Úloha |
|---|---|---|
ItemCatalog | ModuleScript 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. |
InventoryService | ModuleScript v ServerScriptService | Drží sloty všetkých hráčov. Jediný kód, ktorý pridáva, odoberá a skladá predmety do stackov. |
InventoryData | Script v ServerScriptService | Načíta predmety hráča pri vstupe a ukladá ich. |
InventoryActions | Script v ServerScriptService | Overuje a vykonáva požiadavky na vybavenie a použitie. |
ItemPickup | Script vnútri Part | Dá predmet tomu, kto ho zobral. |
InventoryClient | LocalScript v StarterPlayerScripts | Kreslí 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.
- Do ReplicatedStorage vložte Folder s názvom
InventoryRemotes. Dovnútra vložte tri RemoteEvent s názvamiInventoryUpdated,EquipItemaUseItem. - Do ServerStorage vložte Folder s názvom
ItemTools. Dovnútra vložte Tool s názvomSworda do Toolu Part s názvomHandle(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. - Skripty pridávajte postupne podľa krokov. Strom ukazuje, kam každý z nich patrí.
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:
-- 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:
-- 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,
addpridá, čo sa zmestilo, a vráti toto číslo. Volajte najprvspaceFor, keď potrebujete všetko alebo nič, ako to robí zobratie v kroku 5. removefunguje na princípe všetko alebo nič. Požiadavka na 3 jablká pri hráčovi, ktorý má 2, nič neodoberie a vrátifalse, 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.
| Funkcia | Vracia | Na čo |
|---|---|---|
add(player, itemId, amount) | Koľko sa pridalo | Zobratia, odmeny, nákupy |
remove(player, itemId, amount) | true, ak sa odobralo všetko | Použitie, predaj, crafting |
count(player, itemId) | Súčet cez všetky stacky | Zistiť, čo hráč má |
spaceFor(player, itemId) | Koľko sa ešte zmestí | Kontrola pred pridaním na princípe všetko alebo nič |
getEquipped, setEquipped | Id vybaveného predmetu alebo nil | Vybavenie, v kroku 6 |
load, serialize, unload | Kó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:
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
GetAsyncvrá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í.
BindToCloseuloží 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 doSetAsyncspojí 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ť.
- Pridajte Part do Workspace, pomenujte ho
Applea zafarbite načerveno. Zapnite Anchored a vypnite CanCollide, aby doň nikto nenarazil, kým je neviditeľný. Výzva ukazuje názov partu. - S vybraným partom posuňte okno Properties na časť Attributes a kliknite na +. Pridajte
ItemIdtypu string a kliknite na Save, potom nastavte hodnotuapple. Rovnako pridajteAmounttypu number s hodnotou1. - Vložte do partu Script, pomenujte ho
ItemPickupa vložte tento kód:
-- 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:
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)
| Požiadavka | Klient pošle | Server pred akciou overí |
|---|---|---|
EquipItem | Id predmetu | Je 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 |
UseItem | Id predmetu | Rovnaké 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:
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
- 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.
- Kliknite na Sword. Meč sa objaví v ruke a v hotbare a jeho slot dostane fialový rámik. Kliknite znova a odložíte ho.
- Prídite k partu Apple a použite jeho výzvu. Stack jabĺk narastie na 4 a part na 15 sekúnd zmizne.
- Ak chcete otestovať liečenie, najprv znížte zdravie. Prepnite Client/Server na Server, vyberte v Exploreri
Humanoidsvojej postavy, nastavte Health na 50, prepnite späť na Client a kliknite na Apple. - 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.
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.
- 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
- Roblox Creator Docs: Remote events and callbacks (po anglicky). FireClient, OnServerEvent, obmedzenia argumentov a ako sa správy bez príjemcu radia do frontu
- Roblox Creator Docs: Securing the client-server boundary (po anglicky). kontrola vstupov remotov, kontroly ProximityPrompt a podvrhnutie dát v data store
- Roblox Creator Docs: Data stores (po anglicky). GetAsync, SetAsync a zapnutie prístupu zo Studia
- Roblox Creator Docs: Best practices for data stores (po anglicky). jeden kľúč na hráča, vzory kľúčov a pravidelné ukladania
- Roblox Creator Docs: Data store error codes and limits (po anglicky). limity požiadaviek na server a limit veľkosti jednej hodnoty
- Roblox Creator Docs: In-game tools (po anglicky). Handle, ukotvenie, Backpack a StarterGear
- Roblox Creator Docs: Grid and table layouts (po anglicky). veľkosť buniek UIGridLayout, odsadenie a poradie zoraďovania
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.