Röviden
Minden játékos tárgyait egy táblában tárold a szerveren, egy ModuleScriptben a ServerScriptService-ben, és csak ez a kód adhat hozzá, vehet el és rakhat stackekbe tárgyakat. A tárgyakat egyszer írd le egy ModuleScriptben a ReplicatedStorage-ban (id, név, maximális stack). Minden módosítás után a szerver küld ennek a játékosnak egy RemoteEventet az inventoryja másolatával, egy LocalScript pedig rácsként kirajzolja egy ScrollingFrame és egy UIGridLayout segítségével.
- A kliens soha nem ad hozzá tárgyakat. Csak kérni tud, például „szereld fel a kardomat”, és a szerver ellenőrzi, hogy a játékosnál van-e, mielőtt bármit csinálna.
- Tárgyak csak olyan szerverkódon keresztül jelennek meg, amelyet te irányítasz: felvétel, bolti vásárlás szerveroldali ellenőrzés után, jutalmak.
- A tárgyak id-jét és mennyiségét mentsd el, ne a Toolt, a DataStoreService segítségével, amikor a játékos kilép, amikor a szerver leáll, és néhány percenként. Soha ne mentsd el azt a játékost, akinek az adatai nem töltődtek be.
Ezen az oldalon
Hogyan épül fel az inventory
A rendszer hat kis részből áll, mindegyiknek egy feladata van. A tárgyakra vonatkozó összes szabály egyetlen szervermodulban él, így ha valami elromlik, pontosan egy helyen kell keresni.
| Rész | Típus és hely | Feladat |
|---|---|---|
ItemCatalog | ModuleScript a ReplicatedStorage-ban | Mi az egyes tárgy: név, leírás, maximális stack, és hogy felszerelhető vagy használható-e. A szerver és minden kliens olvassa. |
InventoryService | ModuleScript a ServerScriptService-ben | Tárolja minden játékos slotjait. Az egyetlen kód, amely tárgyakat ad hozzá, vesz el és rak stackekbe. |
InventoryData | Script a ServerScriptService-ben | Belépéskor betölti a játékos tárgyait, és elmenti őket. |
InventoryActions | Script a ServerScriptService-ben | Ellenőrzi és végrehajtja a felszerelési és használati kéréseket. |
ItemPickup | Script egy Partban | Kiadja a tárgyat annak, aki felvette. |
InventoryClient | LocalScript a StarterPlayerScripts-ben | Kirajzolja a rácsot, és elküldi a kéréseket. Maga semmit sem módosít. |
Az adatok egy irányba mennek. A szerver módosítja az inventoryt, aztán elküldi ennek a játékosnak az InventoryUpdated eseményt a teljes inventoryval, a kliens pedig újrarajzolja. Amikor a játékos egy slotra kattint, a kliens EquipItem vagy UseItem eseményt küld a tárgy id-jével; a szerver ellenőrzi a kérést, elvégzi a módosítást, és az új másolat ugyanazon az úton érkezik. Az egész inventoryt elküldeni egyszerűbb, mint a változásokat, és néhány tucat slotnál az üzenet kicsi marad.
Miért nem ad hozzá soha tárgyat a kliens
Csábító a tárgyat közvetlenül abban a LocalScriptben hozzáadni, amely megjeleníti: a játékos kattintott, a slot megtelt. Ez kétféleképpen romlik el.
- Senki más nem látja. A LocalScriptben végzett módosítás csak ennek a játékosnak az eszközén létezik. A szerver nem tud róla, ezért nem mentődik, és egyetlen szerverscript sem tudja használni.
- Bárki meghamisíthatja. Ha ezt egy olyan remote-tal javítod, mint az
AddItem(itemId, amount), a csaló maga hívhatja meg ezt az eseményt, bármilyen argumentummal, akárhányszor. A Roblox biztonsági útmutatója szerint a szervernek mindent ellenőriznie kell, amit a kliens küld, mielőtt felhasználja.
Ezért ebben az útmutatóban a kliens csak kérni tud valamit a játékosnál már meglévő tárgyakkal: „szereld fel ezt” és „használd ezt”. Minden kérésben egy tárgy id-je van, mennyiség nélkül, és a szerveren egyetlen ellenőrzésen megy át: szöveg-e, létezik-e ilyen tárgy, van-e belőle legalább egy a játékosnál, és a játékos nem küld-e másodpercenként négynél több kérést. Ezután a szerver maga keresi ki a Toolt a katalógus alapján. Soha nem fogad el a klienstől Toolt, elérési utat vagy instance-t, amire ugyanez az útmutató figyelmeztet.
Tárgyak csak szerverkódon keresztül kerülnek az inventoryba: egy felvétellel, amelyet a szerver ellenőrzött, egy vásárlással, amelyért a szerver levonta a pénzt (ezt a bolt útmutató építi fel), egy küldetés jutalmával vagy dropként. A remote-okról általában, más argumentumtípusok ellenőrzésével, a RemoteEvent útmutatóban olvashatsz.
1. lépés: készítsd elő az Explorert
Ezeket az objektumokat kézzel hozd létre. A következő lépések scriptjei név szerint keresik őket, ezért minden nevet pontosan úgy írj, ahogy itt áll.
- A ReplicatedStorage-ba szúrj be egy Foldert
InventoryRemotesnéven. Ebbe szúrj be három RemoteEventetInventoryUpdated,EquipItemésUseItemnéven. - A ServerStorage-ba szúrj be egy Foldert
ItemToolsnéven. Ebbe szúrj be egy TooltSwordnéven, a Toolba pedig egy PartotHandlenéven (az 1 x 4 x 1 stud teljesen megfelel). Ellenőrizd, hogy a Handle Anchored pipája ki van véve: a Roblox figyelmeztet, hogy a karakter egy helyben ragad, ha anchorolt partokból álló eszközt tart. Egy meglévő Toolod is jó, ha a neve egyezik a 2. lépés katalógusával. - A scripteket a lépések haladtával add hozzá. A fa megmutatja, hová kerül mindegyik.
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
2. lépés: írd le a tárgyakat a katalógusban
A katalógus egyszer leír minden tárgyat, amely létezhet. Az inventoryk ezután csak a tárgy id-jét és a mennyiséget tárolják. Így a mentések kicsik maradnak, és később átnevezhetsz egy tárgyat vagy átírhatod a leírását anélkül, hogy bárki mentett adataihoz hozzányúlnál.
Szúrj be egy ModuleScriptet a ReplicatedStorage-ba, nevezd el ItemCatalog-nak, és cseréld a tartalmát erre:
-- Minden tárgy, amely létezhet a játékban. Ezt a listát a szerver és minden
-- kliens olvassa; csak a szerver dönti el, kinek mi van.
export type Item = {
id: string, -- egyeznie kell az alábbi kulccsal
name: string,
description: string,
maxStack: number, -- mennyi fér el ebből a tárgyból egy slotban
icon: string?, -- opcionális kép: "rbxassetid://" plusz a képed ID-ja
toolName: string?, -- Tool a ServerStorage.ItemTools alatt: a tárgy felszerelhető
heal: number?, -- mennyi életerőt állít vissza: a tárgy elhasználható
}
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 = {}
-- Visszaadja az ezzel az id-vel rendelkező tárgyat, vagy nilt, ha nincs ilyen tárgy
function ItemCatalog.get(id: string): Item?
return items[id]
end
return ItemCatalog
Az opcionális mezők döntik el, mit csinál a tárgy. A toolName felszerelhetővé teszi, a heal használhatóvá, a mindkét mező nélküli tárgy pedig, mint a fa, addig marad az inventoryban, amíg egy másik szerverkód el nem veszi (crafting, eladás).
Új tárgyhoz adj hozzá egy bejegyzést, amelynek a kulcsa és az id-je megegyezik. Az id-k kis- és nagybetűérzékenyek, és éppen ezek mentődnek, ezért soha ne változtasd meg az id-t, ha a tárgy már a játékosoknál van: a name mezőt változtasd.
3. lépés: tárold az inventorykat a szerveren
Ez a ModuleScript birtokolja minden játékos inventoryját. Minden inventory slotok listája, minden slotban egy tárgy id-je és egy mennyiség, plusz egy 20 slotos kapacitás. Más szerverscriptek a függvényeit hívják, és senki más nem szerkeszti a táblát.
Szúrj be egy ModuleScriptet a ServerScriptService-be, és nevezd el InventoryService-nek:
-- Az egyetlen kód, amely módosítja az inventoryt. A ServerScriptService-ben van,
-- ahol a kliensek nem látják és nem is futtathatják.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- A strict mód nem látja, mit ad vissza a WaitForChild-dal kapott require, ezért
-- leírjuk a modulnak azt a részét, amelyet ez a script használ
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 játékosonként
local STARTER_ITEMS: { Slot } = { -- amivel egy teljesen új játékos kezd
{ id = "sword", count = 1 },
{ id = "apple", count = 3 },
}
local inventories: { [Player]: Inventory } = {}
local InventoryService = {}
-- Elküldi a tulajdonosnak az inventoryja másolatát. Minden módosítás után meghívódik.
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
-- Stackszabályok: először feltöltjük a nem teli stackeket, aztán új stackeket kezdünk
-- az üres slotokban. Visszaadja, mennyi került hozzáadásra, ez kevesebb lehet a kértnél.
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
-- Mennyi fér még el a tárgyból: hely a stackjeiben plusz az üres slotok
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
-- Legfeljebb amount darabot ad hozzá a tárgyból. Visszaadja, mennyi került hozzáadásra (0, ha
-- a tárgy nem létezik, az inventory tele van, vagy még nem töltődött be).
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
-- Pontosan amount darabot vesz el a tárgyból, az utolsó stackekkel kezdve.
-- Ha a játékosnak kevesebb van, semmit sem vesz el, és false-t ad vissza.
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
-- Hátulról haladunk, hogy a table.remove ne ugorjon át slotokat
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
-- Akkor hívódik meg, amikor a játékos mentett adatai betöltődtek. A saved az, amit
-- a data store visszaadott: új játékosnál nil. Minden bejegyzés újra átmegy a
-- stackszabályokon, így a törölt tárgyak és a régi stackméretek semmit sem rontanak el.
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
-- Egyszerű másolat a mentéshez, vagy nil, ha a játékos adatai nem töltődtek be
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
A type sorok és a require utáni :: típuskényszerítés csak a Luau típusellenőrzőnek kell, amely nem látja, mit ad vissza a WaitForChild-dal megtalált modul. Játék közben semmit sem változtatnak. Az útmutató többi scriptje ugyanígy tesz.
Így működnek a stackszabályok a fenti katalógussal, ahol az alma 10-ig stackelhető:
- Ha 15 almát adsz egy játékosnak, akinek van egy 7-es stackje, az a stack 10-ig megtelik, aztán új, 5-ös stack indul.
- Amikor elfogynak a slotok, az
addhozzáadja, ami befért, és ezt a számot adja vissza. Ha mindent vagy semmit akarsz, először aspaceFor-t hívd meg, ahogy az 5. lépés felvétele teszi. - A
removea mindent vagy semmit elv szerint működik. Ha 3 almát kérsz egy játékostól, akinek 2 van, semmit sem vesz el, ésfalse-t ad vissza, ezért ellenőrizd az eredményt, mielőtt bármit adnál cserébe. - A slotokban nincsenek lyukak: amikor egy slot kiürül, a többi feljebb csúszik. Így a listát egyszerűbb elküldeni és elmenteni. A helyüket megtartó slotokról a végén lévő kérdésekben olvashatsz.
| Függvény | Visszaad | Mire való |
|---|---|---|
add(player, itemId, amount) | Mennyi került hozzáadásra | Felvétel, jutalmak, vásárlások |
remove(player, itemId, amount) | true, ha mindent elvett | Használat, eladás, crafting |
count(player, itemId) | Összeg az összes stackben | Ellenőrizni, mi van a játékosnál |
spaceFor(player, itemId) | Mennyi fér még el | Ellenőrzés hozzáadás előtt a mindent vagy semmit elv szerint |
getEquipped, setEquipped | A felszerelt tárgy id-je vagy nil | Felszerelés, a 6. lépésben |
load, serialize, unload | Mentésre kész másolat (serialize) | Betöltés és mentés, a 4. lépésben |
4. lépés: töltsd be és mentsd el minden inventoryt
Az inventoryk a szerver memóriájában élnek, ezért eltűnnek, amikor a játékos kilép. Ez a script belépéskor betölti a játékos slotjait egy data store-ból, és visszaírja őket, amikor kilép, amikor a szerver leáll, és hárompercenként arra az esetre, ha a szerver összeomlana. Csak a tárgyak id-jét és mennyiségét menti: a data store-ok nem tudnak Instance-t tárolni, például Toolt.
Szúrj be egy Scriptet a ServerScriptService-be, és nevezd el InventoryData-nak:
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
-- Csak azok a játékosok mentődnek, akiknek az adatai betöltődtek. Sikertelen betöltés után
-- nem szabad menteni, különben egy üres inventory felülírja a valódit.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0
local function keyFor(player: Player): string
return "User_" .. player.UserId
end
-- Egy sikertelen kérés miatt senki sem veszíthet tárgyakat, ezért többször próbálkozunk.
-- A GetDataStore is pcallon belül van, így egy Studio munkamenet data store hozzáférés
-- nélkül figyelmeztetést kap, ahelyett hogy leállítaná ezt a scriptet.
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 -- a játékos kilépett, amíg töltöttünk
end
if ok then
InventoryService.load(player, saved) -- a saved új játékosnál nil
canSave[player] = true
elseif RunService:IsStudio() then
-- Általában azt jelenti, hogy a Studio API services hozzáférése ki van kapcsolva. Kezdő
-- tárgyakkal játszunk, hogy lehessen tesztelni, de soha nem mentjük őket.
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 -- az adatok nem töltődtek be, nincs mit biztonságosan elmenteni
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)
-- Amikor a szerver leáll, mindenkit elmentünk, aki még itt van, és megvárunk minden
-- folyamatban lévő mentést, azokat is, amelyeket a PlayerRemoving indított
game:BindToClose(function()
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
while activeSaves > 0 do
task.wait()
end
end)
-- Néhány percenként mindenkit elmentünk, hogy egy szerverösszeomlás perceket vigyen el, ne az egész munkamenetet
while true do
task.wait(AUTOSAVE_SECONDS)
for _, player in Players:GetPlayers() do
task.spawn(save, player)
end
end
Mit csinál a script, és miért:
- Betöltés alapértékekkel. Egy új játékosnak nincs mentett értéke, ezért a
GetAsyncnilt ad vissza, és a játékos kezdő tárgyakat kap. A mentett slotok újra átmennek a stackszabályokon, így egy katalógusból törölt tárgy vagy egy csökkentett maximális stack nem rontja el a betöltést. Ami már nem fér el, vagy aminek az id-je már nincs a katalógusban, elvész, és a következő mentés ezt véglegessé teszi, ezért minden id-t tarts meg a katalógusban, amely a játékosoknál lehet. - Soha ne ments sikertelen betöltés után. Csak a
canSavejátékosai íródnak. Élő szerveren azt a játékost, akinek az adatai három próbálkozás után sem töltődtek be, megkérjük, hogy csatlakozzon újra. A Studióban ehelyett nem menthető kezdő tárgyakat kap, az újrapróbálkozások miatt néhány másodperccel később. Így lesz ez, amíg a place nincs publikálva bekapcsolt API hozzáféréssel. - Mentés kilépéskor és leálláskor. A
BindToClosemindenkit elment, aki még a szerveren van, és megvárja a már folyamatban lévő mentéseket. A Roblox legfeljebb 30 másodpercet ad a kötött függvényeknek. - Ne lépd túl a limiteket. Játékosonként egy írás hárompercenként plusz egy kilépéskor jóval kevesebb, mint a szerver alapkerete, percenként 60 írás plusz játékosonként 40 (a dokumentáció szerint 2026. szeptember 30-án). A
User_kulcsminta a Roblox ajánlásaiból származik, a user ID átadása aSetAsync-nek pedig ehhez a játékoshoz köti az adatokat, amit a Roblox kifejezetten ajánl az adattörlési kérések kezeléséhez.
Egy kis játékhoz ez megbízható alap. A munkamenet-zárolást, amely megakadályozza, hogy egy gyorsan szervert váltó játékos betöltse az adatait, mielőtt a régi szerver elmentette őket, és hogy mikor használd az UpdateAsync-et a SetAsync helyett, a DataStore útmutató tárgyalja.
5. lépés: adj ki tárgyakat a világból
A felvétel a legegyszerűbb módja, hogy tárgyak kerüljenek az inventoryba: egy part ProximityPrompt-tal, amely hozzáadja a tárgyat, amikor a játékos használja. A script a szerveren figyeli a Triggered eseményét, így a tárgy ott adódik hozzá, ahol a kliens nem tud beavatkozni.
- Adj hozzá egy Partot a Workspace-hez, nevezd el
Apple-nek, és színezd pirosra. Kapcsold be az Anchored, és kapcsold ki a CanCollide beállítást, hogy senki ne ütközzön bele, amíg láthatatlan. A prompt a part nevét mutatja. - A part kijelölése mellett görgess le a Properties ablakban az Attributes részig, és nyomd meg a + gombot. Adj hozzá egy
ItemIdattribútumot string típussal, nyomd meg a Save gombot, aztán állítsd az értékétapple-re. Ugyanígy adj hozzá egy number típusúAmountattribútumot1értékkel. - Szúrj be egy Scriptet a partba, nevezd el
ItemPickup-nak, és illeszd be ezt a kódot:
-- Tedd ezt a Scriptet egy Partba, és adj a Partnak két attribútumot:
-- ItemId (szöveg, például apple) és Amount (szám, például 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 -- valaki más épp most vette fel
end
-- A távolságot a szerveren ellenőrizzük, nem bízunk a kérésben
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 -- nincs elég hely: a tárgyat a helyén hagyjuk
end
InventoryService.add(player, itemId, amount)
prompt.Enabled = false
part.Transparency = 1
task.wait(RESPAWN_SECONDS)
part.Transparency = visibleTransparency
prompt.Enabled = true
end)
Másold a partot, ha több tárgyat akarsz elhelyezni. Az attribútumokat változtasd meg, ha fát, még egy kardot vagy egy stack almát akarsz kiadni.
A Roblox ellenőrzi a távolságot a Triggered eseménynél, de a biztonsági útmutatója mégis azt mondja, hogy a promptokat a szerveren ellenőrizd: a csaló akkor is kiválthatja a prompt eseményeit, amikor az Enabled false, és egy nem anchorolt partot a karakteréhez húzhat. Ezért ellenőrzi a script maga az Enabled értékét és a távolságot, és ezért anchorolt a part.
Bármely más szerverscript ugyanígy ad ki tárgyakat. Vásárlás, küldetés vagy ölés után töltsd be az InventoryService-t require-rel, ahogy a fenti scriptek, és hívd meg az InventoryService.add(player, "wood", 5) függvényt. Ha a tárgy nem veszhet el, először a spaceFor-t ellenőrizd. Egy NPC is lehet forrás: az NPC párbeszéd útmutatóban egy válasz műveletet indít a szerveren, és ez a művelet ugyanígy meghívhatja az InventoryService.add függvényt.
6. lépés: Tool felszerelése és tárgyak használata
Két RemoteEvent viszi az egyetlen kéréseket, amelyeket a kliens küldhet. Az EquipItem a tárgy Tooljának egy másolatát a ServerStorage-ból a játékos Backpackjébe (a képernyő alján lévő hotbarra) és a kezébe teszi, egy újabb kérés pedig elteszi. A UseItem egy darabot elvesz a használható tárgyból, és alkalmazza a hatását, itt ez gyógyítás.
Szúrj be egy Scriptet a ServerScriptService-be, és nevezd el InventoryActions-nek:
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 } = {}
-- Minden kérés itt kezdődik. A kliens bármikor bármit küldhet, ezért
-- ellenőrizzük a típust, hogy a tárgy létezik-e, hogy a játékosnál van-e, és a gyakoriságot.
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
-- Megsemmisíti a tárgy Tooljait, bárhol is van a másolat: hotbar, kéz vagy 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) -- egyszerre egy felszerelt eszköz
local tool = template:Clone()
tool.CanBeDropped = false -- egy eldobott másolatot valaki más felvehetne
tool:SetAttribute("InventoryItem", item.id)
tool.Parent = backpack
-- A StarterGearben lévő második másolat újraéledés után visszamásolódik a Backpackbe
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) -- egyenesen a kézbe
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) -- egy újabb kattintás a felszerelt tárgyra elteszi
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 -- halott vagy már teljes az életereje: nem pazaroljuk el a tárgyat
end
-- Előbb elvesszük a tárgyat, és csak akkor gyógyítunk, ha ez sikerült
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)
| Kérés | A kliens ezt küldi | A szerver ezt ellenőrzi a művelet előtt |
|---|---|---|
EquipItem | A tárgy id-je | Szöveg, a tárgy létezik, a játékosnál van, a kérések nem jönnek másodpercenként négynél sűrűbben, a tárgynak van toolName mezője, és ilyen nevű Tool van a ServerStorage.ItemTools alatt |
UseItem | A tárgy id-je | Ugyanazok a típus-, tulajdonlás- és gyakoriságellenőrzések, a tárgynak van heal értéke, a karakter él és sérült, és egy tárgy elvételre kerül, mielőtt az életerő hozzáadódik |
Három részlet akadályozza meg, hogy a Tool megkettőződjön vagy elvesszen. A másolat CanBeDropped értéke false, mert az eldobott Tool a Workspace-be esik, ahol egy másik játékos elviheti, miközben az eredeti az inventoryban marad. Minden másolat hordoz egy InventoryItem attribútumot, így levételkor minden másolat megtalálható és megsemmisíthető, bárhol is van. Ha pedig a játékosnak van StarterGear tárolója, abba egy második másolat kerül. A Roblox minden megjelenéskor a Backpackbe másolja a StarterGeart, így a felszerelt kard újraéledés után visszajön.
Egyszerre csak egy Tool lehet felszerelve, és a felszerelés nem mentődik, ezért újracsatlakozás után a játékos üres hotbarral kezd. Ha később eladást vagy eldobást adsz hozzá, vedd le a tárgyat, mielőtt az utolsó másolata elhagyja az inventoryt.
A helyőrző kardot valóban harcoló karddá alakíthatod: építs egy Toolt a kard útmutató alapján, hagyd meg a Sword nevét, és tedd az ItemTools mappába a helyőrző helyett. Az abban az útmutatóban szereplő szerverscript minden ütést ellenőriz, akárhogy is kapta meg a játékos a kardot.
7. lépés: rajzold ki az inventory rácsát
A LocalScript az egész ablakot kódból építi fel, így semmit sem kell kézzel elrendezni. A ScrollingFrame tartja a slotokat, a benne lévő UIGridLayout sorokba rendezi őket, az AutomaticCanvasSize pedig a sorok hozzáadásával növeli a görgethető területet.
Az Explorerben nyisd meg a StarterPlayert, szúrj be egy LocalScriptet a StarterPlayerScripts mappába, és nevezd el InventoryClient-nek:
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. Egyszer felépítjük az ablakot. A ResetOnSpawn = false megtartja újraéledések után.
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() -- az AutomaticCanvasSize a cellákhoz növeli
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. Egy cella slotonként. Ez csak kirajzolja, amit a szerver küldött; magát
-- az inventoryt innen soha nem módosítjuk.
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 -- üres 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()
-- Kérünk, nem utasítunk: a szerver ellenőrzi a kérést, és elküldi az eredményt
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
-- A szerver ezt betöltés után és minden módosítás után küldi
inventoryUpdated.OnClientEvent:Connect(render)
-- 3. Megnyitás és bezárás gombbal vagy a B billentyűvel
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)
A StarterPlayerScripts-ben lévő LocalScript munkamenetenként egyszer fut le, a ResetOnSpawn = false pedig megtartja a ScreenGui-t a karakter újraéledésekor, így a rács továbbra is a szerver által küldött utolsó másolatot mutatja.
A kliens minden slothoz rajzol egy cellát, az üreseket is, így egy 20 slotos inventory mindig 20 slotnak látszik. Minden frissítés megsemmisíti a régi cellákat, és újakat épít, ez egyszerű, és néhány tucat slothoz megfelel. Ha a szerver hamarabb küldi el az InventoryUpdated eseményt, mint ahogy ez a script rácsatlakozott, a Roblox sorba állítja az üzenetet, és kézbesíti, amint a kezelő csatlakozik, így az első inventory nem vész el.
Szeretnéd a Studióban megrajzolni az ablakot? Építs egy ScreenGui-t egy sablonslottal, és a makeCell-ben használd a Clone-t. Ikonokhoz adj a katalógusban a tárgynak egy icon mezőt egy általad feltöltött képpel, és a cellája a név helyett a képet mutatja.
Teszteld az inventoryt
- Nyomd meg a Play gombot. Nyisd meg az inventoryt a bal oldali gombbal vagy a B billentyűvel: az új játékosnak van egy Swordja és 3 Apple-je, a számláló pedig 2 / 20 slots értéket mutat. Amíg a Studio nem fér hozzá a data store-okhoz, a tárgyak néhány másodperc múlva jelennek meg, az Outputban megjelenő betöltési figyelmeztetések után, és nem mentődnek.
- Kattints a Swordra. A kard megjelenik a kezedben és a hotbaron, a slotja pedig lila keretet kap. Kattints újra, hogy eltedd.
- Menj oda az Apple parthoz, és használd a promptját. Az almastack 4-re nő, a part pedig 15 másodpercre eltűnik.
- A gyógyítás teszteléséhez először csökkentsd az életerőt. Kapcsold a Client/Server kapcsolót Serverre, jelöld ki a karaktered
Humanoid-ját az Explorerben, állítsd a Health értékét 50-re, válts vissza Clientre, és kattints az Apple-re. - Bekapcsolt Studio API services hozzáféréssel állítsd le a játékot, és indítsd újra. A felvett alma a helyén van. Ha a betöltés vagy a mentés nem sikerült, az Output szólni fog.
Több játékossal való teszteléshez válaszd a teszt beállításaiban a Server & Clients lehetőséget 2 klienssel. Minden játékos csak a saját inventoryját látja, a másik kezében lévő kardot viszont mindketten látják.
Gyakori hibák és megoldásaik
A legtöbb probléma figyelmeztetésként vagy piros hibasorként látszik az Output ablakban. Az elsőt olvasd el: a következő hibák gyakran abból erednek.
Infinite yield possible egy WaitForChild hívásnál
A script egy olyan objektumra vár, amely nem létezik pontosan ezen a néven. Hasonlítsd össze az Explorered az 1. lépés fájával: InventoryRemotes három RemoteEventtel a ReplicatedStorage-ban, ItemTools a ServerStorage-ban és a két modul. A nevek kis- és nagybetűérzékenyek. A script hibák útmutató részletesebben foglalkozik ezzel a figyelmeztetéssel.
A rács megnyílik, de üres marad
A kliens csak azt rajzolja ki, amit a szerver küld. Keress az Outputban Inventory load failed figyelmeztetéseket, és ellenőrizd, hogy az InventoryData Script, nem LocalScript, a ServerScriptService-ben van, és mellette ott az InventoryService ModuleScript. Ha az Output Remote event invocation hibát mutat, a kliensen senki sem figyeli az InventoryUpdated eseményt: keress egy korábbi hibát az InventoryClient-től.
A tárgyak minden alkalommal visszaállnak, amikor a Studióban játszom
Ha az Output azt írja, Inventory not loaded: playing with starter items that will not be saved, a place nincs publikálva, vagy a Studio API services hozzáférése ki van kapcsolva. Kapcsold be a 4. lépésben leírtak szerint, a játékod egy tesztmásolatában.
A kardra kattintás nem csinál semmit
Keresd az Outputban a Cannot equip sword sort: a ServerStorage.ItemTools alatti Toolnak pontosan úgy kell hívnia, mint a katalógusban lévő toolName. A Toolnak ezenkívül kell egy Handle nevű part, hogy fogni lehessen, hacsak nem állítottad a RequiresHandle értékét false-ra.
A felvételi prompt megjelenik, de semmi sem adódik hozzá
Az ItemId attribútumnak pontosan egyeznie kell a katalógus id-jével, a kis- és nagybetűket is beleértve: apple, nem Apple. Semmi sem adódik hozzá, amíg a játékos inventoryja még töltődik, vagy ha nincs hely a teljes mennyiségnek.
A mentés elromlik, miután megváltoztattam, mi mentődik
A data store-ok egyszerű adatokat fogadnak el: szövegeket, számokat, logikai értékeket és ezekből álló táblákat. Egy Tool, Part vagy bármely más Instance mentése hibával leáll, vagy az érték nilként mentődik. A tárgy id-jét és a mennyiséget mentsd, minden mást a katalógusból állíts vissza, ahogy a serialize teszi.
Elkészítés RoCode-dal
Ha egyszerűbb leírnod a rendszert, mint kézzel összerakni, a RoCode megépítheti a nálad nyitott place-ben. Ez egy AI-ügynök a Roblox Studióhoz: a webes chatben leírod a funkciót, a Studio pluginja pedig létrehozza a scripteket és az objektumokat az Explorerben, ahelyett hogy beillesztendő kódot adna.
Adj hozzá egy 20 slotos inventoryt tárgystackekkel, egy UI rácsot, amely B-re nyílik, egy kardot a ServerStorage-ból, amelyet a játékosok felszerelhetnek, gyógyító almákat és mentést a DataStoreService segítségével.
- Ha egy lépésnek szüksége van rá, a Search Game és a Search Scripts segítségével átnézheti a place-edet, hogy a meglévő tárgyakra, remote-okra vagy mentési kódra építsen, ne adjon hozzá egy második rendszert
- A Create Instance segítségével létrehozza a mappákat és a RemoteEventeket, a Create Script segítségével pedig a ModuleScriptet, a Scriptet és a LocalScriptet
- A Build UI segítségével felépítheti az ablak vázát, amelyben ott az inventory elrendezése helyőrző slotokkal; a slotokat a szerverről kitöltő kód külön scriptekben készül
- A Check Script segítségével minden script fordítását ellenőrzi a Studióban, amely elkapja a fordítási hibákat és néhány kockázatos mintát, de nem ellenőriz típusokat, nem lintel, és nem futtatja a kódodat
Minden módosításcsomag egy visszavonási pont a Studióban. A RoCode nem tudja bekapcsolni a Studio API services hozzáférését, ezt neked kell megtenned. 3.9-es vagy újabb pluginnal el tud indítani egy rövid playtestet, és el tudja olvasni a hibákat, 3.9.15-ös vagy újabb pluginnal pedig a tesztkaraktere billentyűket tud nyomni és tárgyakat tud felszerelni, de csak azt ellenőrzi, amit maga döntött el tesztelni, ezért a mentést playtesttel magad ellenőrizd. Az inventory más rendszerekre épül, például a mentésre és az eszközökre, és az AI játékkészítő, amely a saját place-edben épít a Studióban, ezeket egyenként, promptonként adja hozzá. Hogyan csatlakozik a RoCode a Studióhoz.
Gyakori kérdések
Használjam a Roblox Backpackjét saját inventory helyett?
A Backpack a Roblox beépített inventoryja: minden benne lévő Tool gombként jelenik meg a hotbaron. Ha a játékodban minden tárgy Tool, és nincs szükséged stackekre, mennyiségekre és slotlimitre, elég lehet, bár azt, hogy melyik játékosnál milyen Toolok vannak, így is el kell mentened. Saját inventory azokhoz a tárgyakhoz kell, amelyek nem Toolok, például nyersanyagokhoz és elhasználható tárgyakhoz. Ez az útmutató mindkettőt használja: az inventory mindent tárol, a Backpack pedig a felszerelt Toolt tartja.
Hogyan rejtsem el az alapértelmezett hotbart Robloxban?
Egy LocalScriptből hívd meg a StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) függvényt. Ha a hotbar rejtve van, a játékosoknak más módszer kell a felszerelt Tool elővételére és eltevésére, például egy gomb, amely megkéri a szervert, hogy hívja meg a Humanoid:EquipTool vagy a Humanoid:UnequipTools függvényt.
Hogyan érjem el, hogy a slotok megtartsák a helyüket drag and drophoz?
Tárolj egy rögzített hosszúságú listát, slotonként egy bejegyzéssel, és az üres slotokat egy értékkel jelöld, például üres id-vel, ne nillel, mert a Roblox nem javasolja nilt tartalmazó táblák küldését RemoteEventen keresztül. Ezután adj hozzá egy MoveItem RemoteEventet, amely két slotszámot küld, és a szerver ellenőrizze, hogy mindkettő 1 és a kapacitás közötti egész szám, mielőtt felcseréli őket.
Mekkora lehet egy mentett inventory?
Egy data store-érték szerializálás után legfeljebb 4 194 304 karakter lehet (a dokumentáció szerint 2026. szeptember 30-án). Az id-k és mennyiségek listája ennek apró töredékét foglalja el. A mentés méretét a tárgyankénti szöveg növeli, például a saját nevek vagy a tárgyanként mentett hosszú leírások.
Hogyan vegyek és adjak el tárgyakat érmékért?
Mindent a szerveren csinálj. Eladáshoz hívd meg az InventoryService.remove függvényt, és csak akkor fizess, ha true-t adott vissza. Vásárláshoz ellenőrizd az árat és a spaceFor értékét, vond le az érméket, aztán hívd meg az add függvényt. A bolt útmutató a vásárlási oldalt építi fel.
Források és további olvasnivaló
- Roblox Creator Docs: Remote events and callbacks (angolul). FireClient, OnServerEvent, az argumentumok korlátai, és hogyan kerülnek sorba a címzett nélküli üzenetek
- Roblox Creator Docs: Securing the client-server boundary (angolul). a remote-ok bemeneti adatainak ellenőrzése, ProximityPrompt ellenőrzések és adathamisítás a data store-ban
- Roblox Creator Docs: Data stores (angolul). GetAsync, SetAsync és a Studióból való hozzáférés bekapcsolása
- Roblox Creator Docs: Best practices for data stores (angolul). egy kulcs játékosonként, kulcsminták és rendszeres mentések
- Roblox Creator Docs: Data store error codes and limits (angolul). szerverenkénti kéréslimitek és egy érték méretkorlátja
- Roblox Creator Docs: In-game tools (angolul). Handle, anchor, Backpack és StarterGear
- Roblox Creator Docs: Grid and table layouts (angolul). UIGridLayout cellaméret, térközök és rendezési sorrend
Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.