Útmutató · Játékrendszerek

Hogyan készíts inventoryt (tárgylistát) a Roblox Studióban

Az inventory felületi feladatnak tűnik, de hogy feltörhető-e, és elveszít-e tárgyakat, azt az dönti el, hol tárolódnak a tárgyak. Ebben az útmutatóban minden játékos tárgyai egy táblában vannak a szerveren, minden játékos kap egy másolatot, és rácsként rajzolja ki, Toolt szerel fel és elhasználható tárgyakat használ olyan kérésekkel, amelyeket a szerver ellenőriz, és minden egy data store-ba mentődik.

Frissítve 2026. november 20.15 perc olvasásSzerző:

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
  1. Hogyan épül fel
  2. Miért a szerveren a tárgyak
  3. 1. Explorer előkészítése
  4. 2. Tárgykatalógus
  5. 3. Inventory a szerveren
  6. 4. Betöltés és mentés
  7. 5. Tárgyak felvétele
  8. 6. Felszerelés és használat
  9. 7. UI rács
  10. Teszt
  11. Common errors
  12. RoCode-dal
  13. Gyakori kérdések
  14. Források és további olvasnivaló

Hogyan épül fel az inventory

IllusztrációNyomd meg a B-t, vidd az egeret egy tárgy fölé, hogy elolvasd a leírását, és kattints a Swordra, hogy kézbe vedd.

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.

A rendszer részei és hol futnak
RészTípus és helyFeladat
ItemCatalogModuleScript a ReplicatedStorage-banMi 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.
InventoryServiceModuleScript a ServerScriptService-benTárolja minden játékos slotjait. Az egyetlen kód, amely tárgyakat ad hozzá, vesz el és rak stackekbe.
InventoryDataScript a ServerScriptService-benBelépéskor betölti a játékos tárgyait, és elmenti őket.
InventoryActionsScript a ServerScriptService-benEllenőrzi és végrehajtja a felszerelési és használati kéréseket.
ItemPickupScript egy PartbanKiadja a tárgyat annak, aki felvette.
InventoryClientLocalScript a StarterPlayerScripts-benKirajzolja 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.

  1. A ReplicatedStorage-ba szúrj be egy Foldert InventoryRemotes néven. Ebbe szúrj be három RemoteEventet InventoryUpdated, EquipItem és UseItem néven.
  2. A ServerStorage-ba szúrj be egy Foldert ItemTools néven. Ebbe szúrj be egy Toolt Sword néven, a Toolba pedig egy Partot Handle né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.
  3. A scripteket a lépések haladtával add hozzá. A fa megmutatja, hová kerül mindegyik.
Az Explorer, amikor végigértél az útmutatón
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:

ModuleScript helye: ReplicatedStorage neve: ItemCatalog
-- 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:

ModuleScript helye: ServerScriptService neve: InventoryService
-- 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 add hozzáadja, ami befért, és ezt a számot adja vissza. Ha mindent vagy semmit akarsz, először a spaceFor-t hívd meg, ahogy az 5. lépés felvétele teszi.
  • A remove a 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, és false-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.
Mit hívhatnak meg más szerverscriptek
FüggvényVisszaadMire való
add(player, itemId, amount)Mennyi került hozzáadásraFelvétel, jutalmak, vásárlások
remove(player, itemId, amount)true, ha mindent elvettHasználat, eladás, crafting
count(player, itemId)Összeg az összes stackbenEllenőrizni, mi van a játékosnál
spaceFor(player, itemId)Mennyi fér még elEllenőrzés hozzáadás előtt a mindent vagy semmit elv szerint
getEquipped, setEquippedA felszerelt tárgy id-je vagy nilFelszerelés, a 6. lépésben
load, serialize, unloadMenté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:

Script helye: ServerScriptService neve: 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

-- 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 GetAsync nilt 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 canSave já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 BindToClose mindenkit 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 a SetAsync-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.

  1. 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.
  2. A part kijelölése mellett görgess le a Properties ablakban az Attributes részig, és nyomd meg a + gombot. Adj hozzá egy ItemId attribútumot string típussal, nyomd meg a Save gombot, aztán állítsd az értékét apple-re. Ugyanígy adj hozzá egy number típusú Amount attribútumot 1 értékkel.
  3. Szúrj be egy Scriptet a partba, nevezd el ItemPickup-nak, és illeszd be ezt a kódot:
Script helye: az Apple part a Workspace-ben neve: ItemPickup
-- 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:

Script helye: ServerScriptService neve: 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 } = {}

-- 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)
Mit enged meg az egyes kérés
KérésA kliens ezt küldiA szerver ezt ellenőrzi a művelet előtt
EquipItemA tárgy id-jeSzö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
UseItemA tárgy id-jeUgyanazok 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:

LocalScript helye: StarterPlayerScripts neve: 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. 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

  1. 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.
  2. Kattints a Swordra. A kard megjelenik a kezedben és a hotbaron, a slotja pedig lila keretet kap. Kattints újra, hogy eltedd.
  3. Menj oda az Apple parthoz, és használd a promptját. Az almastack 4-re nő, a part pedig 15 másodpercre eltűnik.
  4. 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.
  5. 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.

Te írod

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.

A RoCode elvégzi
  • 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ó

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.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.