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
Hogyan épül fel egy működő bolt
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.
| Rész | Hol található | Mit csinál |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | A tárgyak id-jei, nevei, árai és a Tool, amelyet mindegyik ad. Mindkét oldal olvassa. |
RemoteFunction BuyItem | ReplicatedStorage, a ShopRemotes mappában | Elviszi a vásárlási kérést a szerverre, és visszahozza a választ. |
LocalScript ShopClient | StarterPlayerScripts | Felépíti a bolt ablakát, és elküldi a tárgy id-jét, amikor megnyomják a Buy gombot. |
Script ShopService | ServerScriptService | Ellenőrzi a kérést, levonja a Coins értéket, és kiadja a Toolt. |
| Az eladott Toolok | ServerStorage, a ShopItems mappában | Az eredetik, amelyeket a szerver lemásol. A ServerStorage-ból semmi sem jut el a játékosokhoz. |
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.
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.
- Az Explorerben vidd az egeret a ReplicatedStorage fölé, nyomd meg a + gombot, és szúrj be egy Foldert
ShopRemotesnéven. Ebbe szúrj be egy RemoteFunctiontBuyItemnéven. - Vidd az egeret a ServerStorage fölé, és szúrj be egy Foldert
ShopItemsnéven. - Tegyél a ShopItemsbe minden tárgyhoz egy Toolt
ClassicSword,Flashlight,GrappleHookésSpeedCoilnéven. Az első teszthez elég, ha a Toolban egyetlen, nem anchorolt Part vanHandlené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. - 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:
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.
- Az Explorerben nyisd le a StarterPlayert, vidd az egeret a StarterPlayerScripts fölé, és szúrj be egy LocalScriptet
ShopClientnéven. - Cseréld a tartalmát az alábbi kódra.
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.
| Objektum | Feladata a boltban | Fő tulajdonságok |
|---|---|---|
ScreenGui | Mindent tárol, ami a képernyőre van rajzolva | ResetOnSpawn false, hogy a bolt túlélje az újraéledést |
Frame | Az ablak és minden tárgykártya | AnchorPoint 0.5, 0.5 és Position 0.5, 0.5, hogy az ablak középen legyen |
UISizeConstraint | Korlátozza az ablakot nagy képernyőkön | MaxSize 640 x 460 |
ScrollingFrame | Görgethető, ha több kártya van, mint amennyi elfér | CanvasSize 0 és AutomaticCanvasSize Y, hogy a görgetési terület a kártyákkal együtt nőjön |
UIGridLayout | Sorokba rendezi és tördeli a kártyákat | CellSize 180 x 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | Lekerekíti a sarkokat | CornerRadius 8 és 14 pixel között |
UIPadding | Belső margók | 10 és 12 pixel között minden oldalon |
TextButton | A Shop, a bezárás és a Buy gombok | Az 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:
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.
| A csaló ezt küldi | Ha a szerver elhinné | Mit csinál a ShopService |
|---|---|---|
| 0-s ár | Minden tárgy ingyenes | Figyelmen kívül hagyja. Az ár a katalógusból jön. |
| -1000-es ár | A Coins.Value -= -1000 1 000 érmét ad neki | Figyelmen kívül hagyja. |
NaN ár helyett | Minden összehasonlítás a NaN-nal hamis, ezért a „nincs elég érme” ellenőrzés soha nem fut le | Figyelmen kívül hagyja. |
| Olyan id, amely nincs a katalógusban, vagy tábla szöveg helyett | Hibák a scriptben vagy olyan tárgyak, amelyeket nem akartál eladni | Azt válaszolja: "That item does not exist." |
| Több száz kérés másodpercenként | Terhelé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 Coins | Vásárlások olyan érmékért, amelyek nincsenek neki | Egyá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
- 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.
- 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.
- Á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.
- 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, aleaderstats, aCoinselemet, é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 agiveToolteszi. A bolt ablaka magától frissül, mert figyeli ezeket az attribútumokat. - A pass tulajdonlását nem kell menteni: a
UserOwnsGamePassAsyncminden 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.
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 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ó
- Roblox Creator Docs: Securing the client-server boundary (angolul). remote-argumentumok ellenőrzése, NaN, gyakoriságkorlát és egy játékon belüli bolt példája
- Roblox Creator Docs: Remote events and callbacks (angolul). RemoteFunction, InvokeServer, OnServerInvoke és az InvokeClient kockázatai
- Roblox Creator Docs: Passes (angolul). passok létrehozása és eladása, UserOwnsGamePassAsync és PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (angolul). a játékon belüli Shop, amelyet a Roblox automatikusan létrehoz
- Roblox Creator Docs: Developer Products (angolul). ismételhető vásárlások Robuxért és a ProcessReceipt
- Roblox Creator Docs: StarterGear (angolul). miért jön vissza a StarterGearben lévő Tool újraéledés után
- Roblox Creator Docs: In-game tools (angolul). Handle, anchor és RequiresHandle
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.