Útmutató · Játékrendszerek

Hogyan készíts boltot a Roblox Studióban

Egy Roblox játékban a bolt két feladat: egy GUI, amely megmutatja a tárgyakat, és egy szerverscript, amely eldönti, hogy létrejön-e a vásárlás. Ebben az útmutatóban mindkettőt megépítjük egy érmés bolthoz, amely eszközöket árul, és megmutatjuk, hol van a helye a Robuxos vásárlásoknak.

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

Röviden

A tárgyakat és az árakat egy ModuleScriptben a ReplicatedStorage-ban tárold, az ablakot egy ScreenGui-ból, egy ScrollingFrame-ből és egy UIGridLayout-ból építsd fel, és minden Buy gomb egy RemoteFunction-t hívjon meg, csak a tárgy id-jét átadva. Ezután egy Script a ServerScriptService-ben maga keresi ki az árat, ellenőrzi és levonja a játékos Coins értékét, és kiadja a tárgyat.

  • Soha ne engedd, hogy a kliens küldje az árat. Bárki meghívhatja a remote-jaidat bármilyen értékkel, ezért a szerver a katalógus saját másolatából veszi az árat.
  • A megvett Toolt klónozással add ki a ServerStorage-ból a játékos Backpackjébe (hogy azonnal használhassa) és a StarterGearbe (hogy újraéledés után visszajöjjön).
  • Amit Robuxért árulnak, azok passok és developer productok, ezekkel a MarketplaceService dolgozik. Ezekhez a Roblox ráadásul maga is létrehoz egy Shopot, és ez nem ugyanaz, mint az érmés bolt.
Ezen az oldalon
  1. Hogyan épül fel
  2. 1. Előkészítés
  3. 2. Tárgykatalógus
  4. 3. Bolt GUI
  5. 4. Vásárlás a szerveren
  6. Miért nem küld árat a kliens
  7. 5. Teszt
  8. Game pass
  9. Vásárlások mentése
  10. Common errors
  11. RoCode-dal
  12. Gyakori kérdések
  13. Források és további olvasnivaló

Hogyan épül fel egy működő bolt

IllusztrációA játékos megnyitja a boltot, és 25 érméért megveszi a Flashlightot: a Coins 200-ról 175-re csökken, a gomb Owned-ra vált, az eszköz pedig megjelenik a hotbaron.

Egy valódi játékban működő bolt meg van osztva a játékos eszköze és a szerver között. Az eszköz rajzolja az ablakot, és azt mondja: „meg akarom venni a kardot”. A szerver, az egyetlen fél, amelyben meg lehet bízni, eldönti, hogy ez megtörténik-e. A bolt scriptjei, amelyek „nem működnek”, vagy amelyeket a játékosok csalásokkal feltörnek, gyakran rossz oldalon hozzák meg ezt a döntést.

A bolt öt része
RészHol találhatóMit csinál
ModuleScript ShopCatalogReplicatedStorageA tárgyak id-jei, nevei, árai és a Tool, amelyet mindegyik ad. Mindkét oldal olvassa.
RemoteFunction BuyItemReplicatedStorage, a ShopRemotes mappábanElviszi a vásárlási kérést a szerverre, és visszahozza a választ.
LocalScript ShopClientStarterPlayerScriptsFelépíti a bolt ablakát, és elküldi a tárgy id-jét, amikor megnyomják a Buy gombot.
Script ShopServiceServerScriptServiceEllenőrzi a kérést, levonja a Coins értéket, és kiadja a Toolt.
Az eladott ToolokServerStorage, a ShopItems mappábanAz eredetik, amelyeket a szerver lemásol. A ServerStorage-ból semmi sem jut el a játékosokhoz.
Az Explorer, amikor a bolt kész
ReplicatedStorage
  ShopCatalog ModuleScript new
  ShopRemotes Folder new
    BuyItem RemoteFunction new
ServerStorage
  ShopItems Folder new
    ClassicSword Tool new
      Handle Part
    Flashlight Tool new
    GrappleHook Tool new
    SpeedCoil Tool new
ServerScriptService
  Leaderstats Script
  ShopService Script new
StarterPlayer
  StarterPlayerScripts
    ShopClient LocalScript new

1. lépés: Érmék és eladó tárgyak

A bolt a játékos leaderstatsában lévő Coins értéket költi. Ha végigcsináltad a ranglista útmutatót, ez már megvan, és ezt a scriptet kihagyhatod. Különben tegyél egy Scriptet a ServerScriptService-be Leaderstats néven. Kezdésnek mindenkinek 200 érmét ad, hogy a vásárlásokat azonnal tesztelni lehessen.

Script helye: ServerScriptService neve: Leaderstats
local Players = game:GetService("Players")

local STARTING_COINS = 200 -- elég a bolt teszteléséhez; állítsd 0-ra, amikor a játékosok már tudnak érmét szerezni

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats"

	local coins = Instance.new("IntValue")
	coins.Name = "Coins"
	coins.Value = STARTING_COINS
	coins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Csak egy leaderstats scriptet tarts meg. Két script, amelyek mindegyike leaderstats mappát hoz létre, minden játékosnak két mappát ad, és a bolt a rosszat olvashatja.

Ezután hozd létre az objektumokat, amelyeket a scriptek keresnek. A nevekben számít a kis- és nagybetű, ezért pontosan így írd őket.

  1. Az Explorerben vidd az egeret a ReplicatedStorage fölé, nyomd meg a + gombot, és szúrj be egy Foldert ShopRemotes néven. Ebbe szúrj be egy RemoteFunctiont BuyItem néven.
  2. Vidd az egeret a ServerStorage fölé, és szúrj be egy Foldert ShopItems néven.
  3. Tegyél a ShopItemsbe minden tárgyhoz egy Toolt ClassicSword, Flashlight, GrappleHook és SpeedCoil néven. Az első teszthez elég, ha a Toolban egyetlen, nem anchorolt Part van Handle néven. Bármelyik meglévő Toolod is jó: add meg neki a megfelelő nevet. Valódi sebzést okozó fegyvert a kard útmutató vagy a fegyver útmutató alapján építs; mindkettőben le van írva, hogyan kösd a katalógushoz.
  4. Jelöld ki mindegyik Toolt, és vedd ki a pipát a CanBeDropped elől a Properties ablakban. Ha be van pipálva, a Backspace megnyomása kidobja az eszközt a Workspace-be, és bármelyik játékos felveheti, amiért a vásárló fizetett.

Akár egyetlen Toollal is kezdheted. Ha egy tárgy Toolja hiányzik, a szerver nem hajlandó eladni azt a tárgyat, és figyelmeztetést ír a nevével, így a játékostól semmit sem von le.

2. lépés: Tárgyak és árak a katalógusban

A katalógus az egyetlen lista mindenről, amit a bolt árul. A LocalScript azért olvassa, hogy megrajzolja a kártyákat, a szerver pedig azért, hogy megtalálja az árakat, így az ár megváltoztatása egyetlen módosítás egyetlen helyen.

Vidd az egeret a ReplicatedStorage fölé, szúrj be egy ModuleScriptet, nevezd át ShopCatalog-ra, és cseréld a tartalmát erre:

ModuleScript helye: ReplicatedStorage neve: ShopCatalog
export type ShopItem = {
	id: string, -- később a data store-ba mentődik: ne változtasd meg, ha a tárgy már a játékosoknál van
	name: string, -- a kártyán látszik; nyugodtan módosíthatod
	price: number, -- Coinsban
	description: string,
	toolName: string, -- a Tool a ServerStorage.ShopItems alatt, amelyet a játékos kap
}

-- A kártyák ebben a sorrendben jelennek meg
local items: { ShopItem } = {
	{
		id = "sword",
		name = "Classic Sword",
		price = 50,
		description = "A basic sword for close fights.",
		toolName = "ClassicSword",
	},
	{
		id = "flashlight",
		name = "Flashlight",
		price = 25,
		description = "Lights up dark corners.",
		toolName = "Flashlight",
	},
	{
		id = "grapple",
		name = "Grapple Hook",
		price = 150,
		description = "Reach high ledges.",
		toolName = "GrappleHook",
	},
	{
		id = "speedcoil",
		name = "Speed Coil",
		price = 300,
		description = "Run faster while you hold it.",
		toolName = "SpeedCoil",
	},
}

local byId: { [string]: ShopItem } = {}
for _, item in items do
	byId[item.id] = item
end

local ShopCatalog = {}

ShopCatalog.items = items

-- Visszaadja az ezzel az id-vel rendelkező tárgyat, vagy nilt, ha nincs ilyen tárgy
function ShopCatalog.get(id: string): ShopItem?
	return byId[id]
end

-- A Player attribútuma, amelyet a szerver true-ra állít, ha a tárgy a játékosnál van
function ShopCatalog.ownedAttribute(id: string): string
	return "Owns_" .. id
end

return ShopCatalog

Minden tárgynak van egy id-je és külön egy megjelenített name-je. A szerver az id-t jegyzi fel, amikor valami a játékosnál van, így a „Classic Sword” később átnevezhető anélkül, hogy a mentett vásárlások elromlanának. A leírások csak szövegek a kártyán; hogy mit csinál a Tool, azt a saját scriptjei döntik el.

A játékosok el tudják olvasni a ReplicatedStorage-ban lévő ModuleScriptet, tehát ezek az árak nyilvánosak. Ez rendben van: amúgy is ott állnak a kártyákon. A lényeg az, hogy a kliens és a szerver mindegyike a modul saját másolatát futtatja, így ha egy játékos a saját eszközén megváltoztatja az árakat, a szerveren semmit sem változtat.

3. lépés: A bolt GUI-jának felépítése

Ez a LocalScript az egész ablakot kódból építi fel: a Shop gombot, egy panelt a kártyák görgethető rácsával, minden katalógustárgyhoz egy Buy gombot, egy Coins számlálót és egy állapotsort a szerver válaszaihoz. Mivel minden kódból készül, csak beilleszted, és megnyomod a Play gombot. Az utána következő táblázat felsorol minden objektumot, ha kézzel szeretnéd elrendezni az ablakot.

  1. Az Explorerben nyisd le a StarterPlayert, vidd az egeret a StarterPlayerScripts fölé, és szúrj be egy LocalScriptet ShopClient néven.
  2. Cseréld a tartalmát az alábbi kódra.
LocalScript helye: StarterPlayerScripts neve: ShopClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Amit a ShopCatalog modul visszaad, hogy a szigorú típusellenőrzés ellenőrizze az általunk használt mezőket
type ShopItem = { id: string, name: string, price: number, description: string, toolName: string }
type Catalog = {
	items: { ShopItem },
	get: (id: string) -> ShopItem?,
	ownedAttribute: (id: string) -> string,
}

local ShopCatalog = require(ReplicatedStorage:WaitForChild("ShopCatalog")) :: Catalog
local buyItem = ReplicatedStorage:WaitForChild("ShopRemotes"):WaitForChild("BuyItem") :: RemoteFunction

local player = Players.LocalPlayer

local COLOURS = {
	panel = Color3.fromRGB(24, 20, 36),
	card = Color3.fromRGB(38, 32, 56),
	accent = Color3.fromRGB(124, 77, 255),
	owned = Color3.fromRGB(70, 66, 84),
	text = Color3.fromRGB(240, 238, 245),
	muted = Color3.fromRGB(170, 165, 185),
	good = Color3.fromRGB(120, 220, 150),
}
local REGULAR = Font.fromEnum(Enum.Font.BuilderSans)
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)

local function addCorner(parent: GuiObject, radius: number)
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, radius)
	corner.Parent = parent
end

local function addPadding(parent: GuiObject, pixels: number)
	local padding = Instance.new("UIPadding")
	padding.PaddingTop = UDim.new(0, pixels)
	padding.PaddingBottom = UDim.new(0, pixels)
	padding.PaddingLeft = UDim.new(0, pixels)
	padding.PaddingRight = UDim.new(0, pixels)
	padding.Parent = parent
end

local function newLabel(parent: GuiObject, text: string, textSize: number, font: Font): TextLabel
	local label = Instance.new("TextLabel")
	label.BackgroundTransparency = 1
	label.Text = text
	label.TextSize = textSize
	label.FontFace = font
	label.TextColor3 = COLOURS.text
	label.TextXAlignment = Enum.TextXAlignment.Left
	label.TextWrapped = true
	label.Parent = parent
	return label
end

local function newButton(parent: GuiObject, text: string): TextButton
	local button = Instance.new("TextButton")
	button.BackgroundColor3 = COLOURS.accent
	button.TextColor3 = COLOURS.text
	button.FontFace = BOLD
	button.TextSize = 18
	button.Text = text
	button.Parent = parent
	addCorner(button, 8)
	return button
end

-- ScreenGui: mindent tárol, amit a bolt a játékos képernyőjére rajzol
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- a bolt megmarad, amikor a karakter újraéled

-- Gomb a bal szélen, amely megnyitja és bezárja a boltot
local openButton = Instance.new("TextButton")
openButton.Name = "OpenShop"
openButton.AnchorPoint = Vector2.new(0, 0.5)
openButton.Position = UDim2.new(0, 16, 0.5, 0)
openButton.Size = UDim2.fromOffset(110, 44)
openButton.BackgroundColor3 = COLOURS.accent
openButton.TextColor3 = COLOURS.text
openButton.FontFace = BOLD
openButton.TextSize = 20
openButton.Text = "Shop"
openButton.Parent = gui
addCorner(openButton, 10)

-- A bolt ablaka: középen, rejtve, amíg a játékos meg nem nyitja
local panel = Instance.new("Frame")
panel.Name = "Panel"
panel.AnchorPoint = Vector2.new(0.5, 0.5)
panel.Position = UDim2.fromScale(0.5, 0.5)
panel.Size = UDim2.fromScale(0.8, 0.75)
panel.BackgroundColor3 = COLOURS.panel
panel.Visible = false
panel.Parent = gui
addCorner(panel, 14)
addPadding(panel, 12)

local sizeLimit = Instance.new("UISizeConstraint")
sizeLimit.MaxSize = Vector2.new(640, 460) -- nem engedi, hogy az ablak óriási legyen nagy képernyőkön
sizeLimit.Parent = panel

local title = newLabel(panel, "Shop", 26, BOLD)
title.Size = UDim2.new(0.5, 0, 0, 32)

local coinsLabel = newLabel(panel, "Coins: ...", 20, BOLD)
coinsLabel.AnchorPoint = Vector2.new(1, 0)
coinsLabel.Position = UDim2.new(1, -44, 0, 0)
coinsLabel.Size = UDim2.new(0.5, -44, 0, 32)
coinsLabel.TextXAlignment = Enum.TextXAlignment.Right

local closeButton = newButton(panel, "X")
closeButton.AnchorPoint = Vector2.new(1, 0)
closeButton.Position = UDim2.fromScale(1, 0)
closeButton.Size = UDim2.fromOffset(32, 32)
closeButton.BackgroundColor3 = COLOURS.card

-- Itt jelennek meg a szerver válaszai, például "You need 20 more coins."
local status = newLabel(panel, "", 18, REGULAR)
status.AnchorPoint = Vector2.new(0, 1)
status.Position = UDim2.fromScale(0, 1)
status.Size = UDim2.new(1, 0, 0, 24)
status.TextColor3 = COLOURS.muted

-- ScrollingFrame: görgethető terület, ha több kártya van, mint amennyi elfér
local list = Instance.new("ScrollingFrame")
list.Name = "Items"
list.Position = UDim2.fromOffset(0, 44)
list.Size = UDim2.new(1, 0, 1, -76)
list.BackgroundTransparency = 1
list.BorderSizePixel = 0
list.ScrollBarThickness = 6
list.ScrollingDirection = Enum.ScrollingDirection.Y
list.CanvasSize = UDim2.new() -- nulláról indul; az AutomaticCanvasSize a kártyákhoz nyújtja
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel

-- UIGridLayout: sorokba rendezi a kártyákat, és a következő sorba töri őket
local grid = Instance.new("UIGridLayout")
grid.CellSize = UDim2.fromOffset(180, 200)
grid.CellPadding = UDim2.fromOffset(12, 12)
grid.SortOrder = Enum.SortOrder.LayoutOrder
grid.Parent = list

local function makeCard(item: ShopItem, order: number)
	local card = Instance.new("Frame")
	card.Name = item.id
	card.LayoutOrder = order
	card.BackgroundColor3 = COLOURS.card
	card.Parent = list
	addCorner(card, 10)
	addPadding(card, 10)

	local nameLabel = newLabel(card, item.name, 20, BOLD)
	nameLabel.Size = UDim2.new(1, 0, 0, 26)

	local description = newLabel(card, item.description, 15, REGULAR)
	description.Position = UDim2.fromOffset(0, 30)
	description.Size = UDim2.new(1, 0, 1, -80)
	description.TextColor3 = COLOURS.muted
	description.TextYAlignment = Enum.TextYAlignment.Top

	local buyButton = newButton(card, "")
	buyButton.Name = "Buy"
	buyButton.AnchorPoint = Vector2.new(0, 1)
	buyButton.Position = UDim2.fromScale(0, 1)
	buyButton.Size = UDim2.new(1, 0, 0, 40)

	local ownedAttribute = ShopCatalog.ownedAttribute(item.id)
	local busy = false

	local function refresh()
		if player:GetAttribute(ownedAttribute) == true then
			buyButton.Text = "Owned"
			buyButton.BackgroundColor3 = COLOURS.owned
			buyButton.AutoButtonColor = false
		else
			buyButton.Text = `Buy: {item.price} coins`
			buyButton.BackgroundColor3 = COLOURS.accent
			buyButton.AutoButtonColor = true
		end
	end

	buyButton.Activated:Connect(function()
		if busy or player:GetAttribute(ownedAttribute) == true then
			return
		end
		busy = true
		buyButton.Text = "Buying..."

		-- Csak a tárgy id-jét küldjük. Az árat a szerver maga keresi ki.
		local ok, bought, message = pcall(function()
			return buyItem:InvokeServer(item.id)
		end)
		if ok and type(message) == "string" then
			status.Text = message
			status.TextColor3 = if bought == true then COLOURS.good else COLOURS.muted
		else
			status.Text = "The shop did not answer. Try again."
			status.TextColor3 = COLOURS.muted
		end

		busy = false
		refresh()
	end)

	-- A szerver akkor állítja be ezt az attribútumot, amikor a vásárlás sikerült (vagy amikor a mentett tárgyak betöltődtek)
	player:GetAttributeChangedSignal(ownedAttribute):Connect(refresh)
	refresh()
end

for index, item in ShopCatalog.items do
	makeCard(item, index)
end

openButton.Activated:Connect(function()
	panel.Visible = not panel.Visible
	status.Text = ""
end)

closeButton.Activated:Connect(function()
	panel.Visible = false
end)

gui.Parent = player:WaitForChild("PlayerGui")

-- Megmutatjuk a játékos érméit. A valódi érték a szervernél van; itt csak megjelenítjük.
local leaderstats = player:WaitForChild("leaderstats")
local coins = leaderstats:WaitForChild("Coins") :: IntValue
local function updateCoins()
	coinsLabel.Text = `Coins: {coins.Value}`
end
coins.Changed:Connect(updateCoins)
updateCoins()

A gombok az Activated eseményt használják, nem a MouseButton1Click-et: ez egérkattintásra, telefonos érintésre és a kontroller A vagy X gombjára is lefut.

A fenti type definíciók leírják, mit ad vissza a ShopCatalog, hogy a szigorú típusellenőrzés elkapjon egy elírást a mezőnévben, például item.prise. Amikor a játék fut, semmit sem változtatnak.

GUI objektumok és fontos tulajdonságok
ObjektumFeladata a boltbanFő tulajdonságok
ScreenGuiMindent tárol, ami a képernyőre van rajzolvaResetOnSpawn false, hogy a bolt túlélje az újraéledést
FrameAz ablak és minden tárgykártyaAnchorPoint 0.5, 0.5 és Position 0.5, 0.5, hogy az ablak középen legyen
UISizeConstraintKorlátozza az ablakot nagy képernyőkönMaxSize 640 x 460
ScrollingFrameGörgethető, ha több kártya van, mint amennyi elférCanvasSize 0 és AutomaticCanvasSize Y, hogy a görgetési terület a kártyákkal együtt nőjön
UIGridLayoutSorokba rendezi és tördeli a kártyákatCellSize 180 x 200, CellPadding 12, SortOrder LayoutOrder
UICornerLekerekíti a sarkokatCornerRadius 8 és 14 pixel között
UIPaddingBelső margók10 és 12 pixel között minden oldalon
TextButtonA Shop, a bezárás és a Buy gombokAz Activated esemény

Ha kézzel szeretnéd megrajzolni az ablakot, építsd fel ugyanezeket az objektumokat a StarterGui-ban ezekkel a tulajdonságokkal, ott is állítsd a ScreenGui ResetOnSpawn tulajdonságát false-ra, és hagyj meg egy kártyát sablonnak, amelyet a LocalScript minden katalógustárgyhoz klónoz. Ekkor a script csak kitölti a kártyákat és beköti a gombokat. A vásárlás logikája a következő lépésben nem változik.

Ha a játékod főmenüvel indul, abban az útmutatóban van egy sor, amelyet a ShopClienthez kell adni, hogy a Shop gomb csak azután jelenjen meg, hogy a játékos megnyomta a Play gombot. Ha azt szeretnéd, hogy a bolt egy eladóval való beszélgetéssel nyíljon meg, az NPC párbeszéd útmutató megmutatja, hogyan adj hozzá egy OpenShop műveletet, amely megnyittatja az ablakot a ShopClienttel, a vásárlások pedig ugyanúgy a bolt szerveroldali ellenőrzésein mennek át.

4. lépés: Ellenőrzés és vásárlás a szerveren

Ez a Script az egyetlen hely, ahol vásárlás történhet. Megkapja a tárgy id-jét, ellenőrzi, kikeresi az árat, ellenőrzi a játékos Coins értékét, aztán levonja az érméket, és kiadja a Toolt. A Buy gombnak true vagy false értékkel és egy megjelenítendő üzenettel válaszol.

Vidd az egeret a ServerScriptService fölé, szúrj be egy Scriptet ShopService néven, és illeszd be ezt:

Script helye: ServerScriptService neve: ShopService
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Amit a ShopCatalog modul visszaad, hogy a szigorú típusellenőrzés ellenőrizze az általunk használt mezőket
type ShopItem = { id: string, name: string, price: number, description: string, toolName: string }
type Catalog = {
	items: { ShopItem },
	get: (id: string) -> ShopItem?,
	ownedAttribute: (id: string) -> string,
}

local ShopCatalog = require(ReplicatedStorage:WaitForChild("ShopCatalog")) :: Catalog
local buyItem = ReplicatedStorage:WaitForChild("ShopRemotes"):WaitForChild("BuyItem") :: RemoteFunction
local shopItems = ServerStorage:WaitForChild("ShopItems")

local COOLDOWN_SECONDS = 0.5
local lastRequest: { [Player]: number } = {}

local function giveTool(player: Player, template: Tool)
	-- Backpack: a játékos azonnal használhatja az eszközt
	local backpack = player:FindFirstChildOfClass("Backpack")
	if backpack then
		template:Clone().Parent = backpack
	end
	-- StarterGear: a Roblox minden megjelenéskor újra a Backpackbe másolja
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		template:Clone().Parent = starterGear
	end
end

local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
	-- 1. A kliens csak a tárgy id-jét küldi, tehát ennek szövegnek kell lennie
	if type(itemId) ~= "string" then
		return false, "That item does not exist."
	end

	-- 2. Figyelmen kívül hagyjuk a dupla kattintásokat és a scriptekből jövő kérésáradatokat
	local now = os.clock()
	local last = lastRequest[player]
	if last and now - last < COOLDOWN_SECONDS then
		return false, "Slow down a little."
	end
	lastRequest[player] = now

	-- 3. A tárgyat a katalógus saját szerveroldali másolatában keressük
	local item = ShopCatalog.get(itemId)
	if not item then
		return false, "That item does not exist."
	end

	local ownedAttribute = ShopCatalog.ownedAttribute(item.id)
	if player:GetAttribute(ownedAttribute) == true then
		return false, "You already own this."
	end

	local template = shopItems:FindFirstChild(item.toolName)
	if not (template and template:IsA("Tool")) then
		warn(`ShopItems has no Tool named {item.toolName} for shop item {item.id}`)
		return false, "This item is not available right now."
	end

	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if not (coins and coins:IsA("IntValue")) then
		return false, "Your coins have not loaded yet."
	end

	-- 4. Az ár a katalógusból jön, soha nem a klienstől
	if coins.Value < item.price then
		return false, `You need {item.price - coins.Value} more coins.`
	end

	-- 5. Levonjuk az érméket, aztán kiadjuk a tárgyat. Itt semmi sem adja át a futást, így ugyanattól a játékostól
	-- érkező két kérés nem mehet át mindkettő a fenti ellenőrzéseken, mielőtt ez lefutott.
	coins.Value -= item.price
	giveTool(player, template)
	player:SetAttribute(ownedAttribute, true)

	return true, `You bought {item.name}.`
end

buyItem.OnServerInvoke = onBuyItem

Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)

A tulajdonlás a Player attribútumaként tárolódik, például Owns_sword. A szerver által beállított attribútumok replikálódnak a játékos eszközére, így a LocalScript át tudja kapcsolni a kártyát „Owned” állapotra. Amit a játékos a saját másolatában módosít, az nem jut el a szerverig.

A Tool két helyre kerül. A Backpackbe tett másolat azonnal megjelenik a hotbaron. A StarterGearbe tett másolatot a Roblox minden alkalommal az új Backpackbe teszi, amikor a karakter megjelenik. Nélküle a megvett tárgy a játékos első halálakor eltűnne.

Miért nem küldi soha a kliens az árat

Mindent, ami a játékos eszközén van, az a játékos meg is tud változtatni. A csalók a saját kódjukat futtatják a játék saját másolatukban: el tudják olvasni a LocalScriptjeidet, módosíthatják a GUI-t, és tetszőleges argumentumokkal, akárhányszor meghívhatják a BuyItem:InvokeServer() függvényt. A Roblox biztonsági útmutatója azt mondja, hogy mindennek, amit egy remote kap, ellenőrizni kell a típusát és az értékét is, és példaként éppen egy boltot hoz.

Mi történik, ha a szerver megbízik a kliensben
A csaló ezt küldiHa a szerver elhinnéMit csinál a ShopService
0-s árMinden tárgy ingyenesFigyelmen kívül hagyja. Az ár a katalógusból jön.
-1000-es árA Coins.Value -= -1000 1 000 érmét ad nekiFigyelmen kívül hagyja.
NaN ár helyettMinden összehasonlítás a NaN-nal hamis, ezért a „nincs elég érme” ellenőrzés soha nem fut leFigyelmen kívül hagyja.
Olyan id, amely nincs a katalógusban, vagy tábla szöveg helyettHibák a scriptben vagy olyan tárgyak, amelyeket nem akartál eladniAzt válaszolja: "That item does not exist."
Több száz kérés másodpercenkéntTerhelés a szerveren, és az ellenőrzések bármely rése több százszor kihasználhatóJátékosonként legfeljebb egy kérést dolgoz fel fél másodpercenként.
A saját képernyőjén megváltoztatott CoinsVásárlások olyan érmékért, amelyek nincsenek nekiEgyáltalán nem látja. A szerver csak a saját Coins értékét olvassa.

Ez a szabály minden remote-ra érvényes, amelyet írsz: azt küldd el, amit a játékos választott, például a tárgy id-jét vagy a slot számát, és soha azt, hogy mennyibe kerül, vagy mit kellene kapnia. A RemoteEvent útmutató részletesebben foglalkozik a remote-argumentumok ellenőrzésével.

5. lépés: A bolt tesztelése

  1. Nyomd meg a Play gombot. Bal oldalt megjelenik a Shop gomb. Nyisd meg, és vedd meg a Flashlightot: a Coins 25-tel csökken, az eszköz megjelenik a hotbaron, a gombja pedig Owned-ra vált.
  2. Próbáld meg a Speed Coilt, amely 300-ba kerül. Az állapotsor kiírja, hány érme hiányzik még, és semmi sem kerül levonásra.
  3. Állítsd vissza a karaktert a játékon belüli menüből. A Flashlight a StarterGearben lévő másolatnak köszönhetően visszakerül az új Backpackbe.
  4. Ha teszt közben érmét akarsz adni magadnak, nyomd meg a Client/Server kapcsolót, és válts Serverre, keresd meg az Explorerben a Players, a saját neved, a leaderstats, a Coins elemet, és változtasd meg a Value értékét a Properties ablakban. Ugyanez Client módban csak a te képernyődet változtatja meg, és pontosan ez az a fajta változás, amelyet a szerver figyelmen kívül hagy.

Ha a gomb azt válaszolja, "The shop did not answer", nyisd meg az Output ablakot a Studio Window menüjéből, és keresd meg a ShopService piros hibáját. Ha viszont a gomb a "Buying..." feliraton ragad, akkor a ShopService nem fut, vagy elakadt egy objektumra várva: nézd meg a gyakori hibákat.

Game pass eladása Robuxért

Az érme a saját pénznemed, ezért a fenti bolt maga dönt minden vásárlásról. Ami Robuxért vásárolható, az másképp működik: a game passt egyszer veszik meg, és örökre megmarad (VIP-bónuszok, állandó eszköz), a developer productot pedig újra és újra meg lehet venni (egy csomag érme, pályaátugrás). Mindkettő a Roblox MarketplaceService-én megy át, és a fizetést a Roblox fogadja, nem a scripted.

Ebből az útmutatóból két szabály vihető át: a vásárlási ablakot a kliensen egy gombbal indítsd, a bónuszt pedig csak a szerveren add ki, amikor a Roblox megerősítette a vásárlást, vagy a pass már a játékosnál van. A game pass script útmutató ezt teljes egészében felépíti: tulajdonlás ellenőrzése belépéskor, vásárlási ablak, bónuszok, például VIP-ajtó, és hogy mikor jobb a pass helyett developer productot választani. Az ár kiválasztásához az ingyenes Robux jutalék kalkulátor megmutatja, mennyit hoz neked egy pass vagy developer product a Roblox részesedése után.

A játékosok vásárlásainak mentése

Minden, amit eddig csináltunk, egy munkamenetig él: az érmék és a megvett tárgyak elvesznek, amikor a játékos kilép, amíg el nem mented őket egy data store-ba. Hogy ne ismételjük meg itt a mentés kódját, csináld végig a DataStore útmutatót (vagy a ranglista útmutató 3. lépését, ott rövidebb a változat), és tartsd szem előtt a bolt szabályait:

  • A tárgyak id-jeit mentsd el, például { "sword", "flashlight" }, ugyanabban a táblában, mint a Coins értéket, hogy egyetlen mentés írja be az elköltött érméket és a megvett tárgyat is. Toolt és más instance-eket nem lehet data store-ba tenni.
  • Amikor az adatok betöltődtek, menj végig a mentett id-ken, hagyd ki azokat, amelyek már nincsenek a katalógusban, állítsd be mindegyik Owns_ attribútumot, és add ki a Toolt ugyanúgy, ahogy a giveTool teszi. A bolt ablaka magától frissül, mert figyeli ezeket az attribútumokat.
  • A pass tulajdonlását nem kell menteni: a UserOwnsGamePassAsync minden belépéskor megkérdezi a Robloxot.
  • Soha ne mentsd el azt a játékost, akinek az adatai nem töltődtek be, különben egy sikertelen betöltés üres listára cserélheti a vásárlásait.

Gyakori hibák és megoldásaik

Ha a bolt furcsán viselkedik, először ezt ellenőrizd. Mindenekelőtt nyisd meg az Output ablakot (Window menü, aztán Output): a script hibája megnevezi a scriptet és a sort.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'

A script egy olyan objektumra vár, amely ezen a pontos néven nem létezik. Ellenőrizd a ShopRemotes, BuyItem, ShopCatalog és ShopItems írásmódját és nagybetűit, és hogy a ShopItems a ServerStorage-ban van, nem a ReplicatedStorage-ban. A script hibák útmutató részletesen foglalkozik ezzel a figyelmeztetéssel.

A Buy gomb a "Buying..." feliraton ragad, és nem válaszol

A szerveren senki sem állította be a BuyItem.OnServerInvoke értékét, ezért a Roblox addig tartja a kérést, amíg ez meg nem történik. Győződj meg róla, hogy a ShopService Script, nem LocalScript, és a ServerScriptService-ben van, és keress az Outputban Infinite yield possible figyelmeztetést a ShopService-től: ez azt jelenti, hogy a script elakadt a ShopCatalog, a ShopRemotes vagy a ShopItems várásában.

A Buy gomb azt írja, "The shop did not answer"

A szerverhívás hibával leállt ahelyett, hogy választ adott volna. A szokásos ok egy hiba a ShopService-ben a kérés feldolgozása közben, ezért keresd meg az Outputban a ShopService piros hibáját: benne van a sor.

A gomb azt írja, "This item is not available right now"

A szerver nem talált a tárgy toolName értékével egyező Toolt a ServerStorage, ShopItems alatt. Az Outputban ott a figyelmeztetés a pontos névvel, amelyet keresett.

Megvettem az eszközt, de a karakter nem tudja fogni, vagy beragad

A Toolban közvetlenül pontosan egy Handle nevű partnak kell lennie, és egyik partja sem lehet anchorolt. Olyan eszköznél, amelyet nem kell kézben tartani, inkább vedd ki a pipát a RequiresHandle elől.

Az érmék az én képernyőmön csökkentek, de a többieknél nem

A vásárlás egy LocalScriptben történt, ezért csak a te eszközöd változott. Tedd át az érmék levonását és a Tool kiadását egy szerveroldali Scriptbe, ahogy a 4. lépésben.

A megvett tárgyak újracsatlakozás után eltűnnek

Egyelőre semmi sem mentődik. Lásd a vásárlások mentését.

Elkészítés RoCode-dal

Ha nincs kedved mindezt kézzel összerakni, a RoCode megcsinálhatja a nálad nyitott place-ben. Ez egy független AI-ügynök kódoláshoz: a webes chatjében leírod a funkciót, a Roblox Studio pluginja pedig létrehozza a scripteket, a remote-ot és a GUI-t az Explorerben, így semmit sem kell a chatablakból kimásolnod.

Te írod

Adj hozzá egy érmés boltot: egy Shop gombot, amely megnyit egy rácsot négy eszközzel, Coins árakkal a leaderstatsomból. A szerver ellenőrizze az árat, és adja ki az eszközt a Backpackbe és a StarterGearbe.

A RoCode elvégzi
  • A Search Scripts és a Read Script segítségével átnézheti a place-edet meglévő leaderstats és boltkód után kutatva, hogy a te Coins értékedet használja, ne adjon hozzá egy másodikat
  • A Build UI segítségével felépítheti az ablak vázát: a bolt elrendezése helyőrző kártyákkal és egy LocalScripttel érkezik a hover effektekhez és a Close gombhoz; a vásárlás logikája külön scriptekben készül
  • A Create Instance segítségével létrehozza a RemoteFunctiont, a Create Script segítségével pedig megírja a katalógus ModuleScriptjét, a szerver Scriptet és a LocalScriptet
  • A Check Script segítségével minden script fordítását ellenőrzi a Studióban (típusokat nem ellenőriz, és scripteket nem futtat), és minden módosításcsomag egy visszavonási pont a Studióban

A passokat továbbra is magadnak kell létrehoznod a Creator Hubban, mert a RoCode nem tud passokat és developer productokat létrehozni, és a vásárlásokat is te teszteled: 3.9-es vagy újabb pluginnal a RoCode 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 meg tudja nyomni a Shop és a Buy gombokat, de csak azt ellenőrzi, amit maga döntött el tesztelni. A bolt általában az alap játékmenet és a mentés után következik; a RoCode-dal végzett lépésenkénti játékkészítési ciklus megmutatja, hol a helye. Hogyan csatlakozik a RoCode a Studióhoz.

Gyakori kérdések

Mi a jobb egy Roblox Buy gombhoz: RemoteEvent vagy RemoteFunction?

Mindkettő jó, ha a szerver ellenőriz. A RemoteFunction lehetővé teszi, hogy a gomb megvárja és megmutassa a szerver válaszát, ezért ez az útmutató ezt használja, és a Roblox biztonsági útmutatójának bolt példája is RemoteFunctiont használ. Csak a kliensről hívd meg: az a szerver, amely InvokeClient-et hív, örökké várhat, ha a kliens soha nem válaszol. A RemoteEvent útmutató összehasonlítja a kettőt.

Hogyan nyissam meg a boltot egy NPC-vel gomb helyett?

Tegyél egy ProximityPrompt-ot az NPC valamelyik partjába, például a HumanoidRootPartjába, figyeld a Triggered eseményét egy szerveroldali Scriptben, és küldj ennek a játékosnak egy RemoteEventet, hogy a LocalScript megmutassa a panelt. Ha csak az NPC közelében lehet vásárolni, a BuyItem kezelőjében is ellenőrizd a távolságot az NPC-től, mert a kliens bárhonnan meghívhatja a remote-ot.

Hogyan áruljak olyan tárgyakat, amelyeket többször is meg lehet venni?

Ezeknél a tárgyaknál hagyd ki a „már megvan” ellenőrzést, és Tool helyett valami megszámolhatót adj, például adj hozzá 1-et egy IntValue-hoz, amely a bájitalokat számolja. Az árkeresést és az érmék ellenőrzését hagyd úgy, ahogy van.

Miért tűnik el a bolt, amikor a karakter újraéled?

A ScreenGui ResetOnSpawn tulajdonsága true, ez az alapértelmezett, ezért a Roblox újraéledéskor törli. Állítsd false-ra, ahogy a 3. lépés scriptje teszi.

Használhatok ingyenes bolt GUI sablont?

Igen, bármelyik elrendezés jó, ha a Buy gombjai csak a tárgy id-jét küldik, maga a vásárlás pedig egy szerveroldali Scriptben történik, mint a ShopService. Mielőtt sablont használsz, ellenőrizd, hogy nem LocalScriptben vonja-e le az érméket, vagy adja-e ki a tárgyakat.

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.