Ve zkratce
Předměty a ceny držte v ModuleScriptu v ReplicatedStorage, okno postavte ze ScreenGui, ScrollingFrame a UIGridLayout a ať každé tlačítko Buy volá RemoteFunction a předává jen id předmětu. Dál si Script v ServerScriptService sám najde cenu, zkontroluje a strhne Coins hráče a vydá předmět.
- Nikdy nedovolte klientovi posílat cenu. Kdokoli může vaše remoty volat s jakýmikoli hodnotami, proto server bere cenu ze své kopie katalogu.
- Koupený Tool vydejte klonováním ze ServerStorage do Backpacku hráče (aby šel hned použít) a do StarterGear (aby se vrátil po respawnu).
- Co se prodává za Robux, jsou passy a developer products a pracuje s nimi MarketplaceService. Pro ně Roblox navíc sám vytváří Shop, a to není totéž jako obchod za mince.
Na této stránce
Jak je funkční obchod postavený
Obchod, který funguje ve skutečné hře, je rozdělený mezi zařízení hráče a server. Zařízení kreslí okno a říká „chci koupit meč“. Server, jediná strana, které lze věřit, rozhoduje, jestli se to stane. Skripty obchodu, které „nefungují“ nebo které hráči rozbíjejí podvody, často dělají toto rozhodnutí na špatné straně.
| Část | Kde je | Co dělá |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | Id předmětů, názvy, ceny a Tool, který každý z nich dává. Čtou ho obě strany. |
RemoteFunction BuyItem | ReplicatedStorage, ve složce ShopRemotes | Nese požadavek na nákup na server a odpověď zpět. |
LocalScript ShopClient | StarterPlayerScripts | Postaví okno obchodu a pošle id předmětu, když se klikne na tlačítko Buy. |
Script ShopService | ServerScriptService | Ověří požadavek, strhne Coins a vydá Tool. |
| Tools, které prodáváte | ServerStorage, ve složce ShopItems | Originály, které server kopíruje. Nic ze ServerStorage se hráčům neposílá. |
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
Krok 1: Mince a předměty na prodej
Obchod utrácí hodnotu Coins v leaderstats hráče. Pokud jste prošli návod k leaderboardu, už ji máte a tento skript můžete vynechat. Jinak vložte Script do ServerScriptService s názvem Leaderstats. Každému dá na začátek 200 mincí, abyste mohli nákupy testovat hned.
local Players = game:GetService("Players")
local STARTING_COINS = 200 -- na test obchodu to stačí; až budou hráči moct mince vydělávat, nastavte 0
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
Mějte jen jeden skript leaderstats. Dva skripty, z nichž každý vytváří složku leaderstats, dají každému hráči dvě složky a obchod může přečíst tu špatnou.
Dál vytvořte objekty, které skripty hledají. Na velikosti písmen v názvech záleží, proto je pište přesně jako tady.
- V Exploreru najeďte myší na ReplicatedStorage, klikněte na tlačítko + a vložte Folder s názvem
ShopRemotes. Do ní vložte RemoteFunction s názvemBuyItem. - Najeďte myší na ServerStorage a vložte Folder s názvem
ShopItems. - Do ShopItems dejte jeden Tool na každý předmět, s názvy
ClassicSword,Flashlight,GrappleHookaSpeedCoil. Na první test stačí v Toolu jeden neukotvený Part s názvemHandle. Poslouží i jakýkoli Tool, který už máte: dejte mu správný název. Zbraně, které opravdu způsobují poškození, postavte podle návodu k meči nebo návodu ke zbrani; v každém je napsané, jak je propojit s katalogem. - Vyberte každý Tool a v okně Properties odškrtněte CanBeDropped. Když je zaškrtnuté, stisk Backspace vyhodí nástroj do Workspace a kterýkoli hráč může sebrat to, za co kupující zaplatil.
Začít můžete i s jediným Toolem. Pokud Tool předmětu chybí, server ho odmítne prodat a vypíše varování s jeho názvem, takže hráči se nic nestrhne.
Krok 2: Předměty a ceny v katalogu
Katalog je jediný seznam všeho, co obchod prodává. LocalScript ho čte, aby nakreslil karty, a server ho čte, aby našel ceny, takže změna ceny je jedna úprava na jednom místě.
Najeďte myší na ReplicatedStorage, vložte ModuleScript, přejmenujte ho na ShopCatalog a nahraďte obsah tímto:
export type ShopItem = {
id: string, -- potom se ukládá do úložiště dat: neměňte ho, když předmět už hráči mají
name: string, -- ukazuje se na kartě; měnit se smí
price: number, -- v Coins
description: string,
toolName: string, -- Tool v ServerStorage.ShopItems, který hráč dostane
}
-- Karty se objeví v tomto pořadí
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
-- Vrátí předmět s tímto id, nebo nil, pokud takový předmět není
function ShopCatalog.get(id: string): ShopItem?
return byId[id]
end
-- Atribut Player, který server nastaví na true, když hráč předmět má
function ShopCatalog.ownedAttribute(id: string): string
return "Owns_" .. id
end
return ShopCatalog
Každý předmět má id a zvlášť zobrazovaný name. Server zapisuje právě id, když hráč něco má, takže "Classic Sword" můžete později přejmenovat, aniž byste rozbili uložené nákupy. Popisy jsou jen text na kartě; co Tool dělá, rozhodují jeho vlastní skripty.
Hráči mohou ModuleScript v ReplicatedStorage přečíst, takže tyto ceny jsou veřejné. To nevadí: stejně jsou napsané na kartách. Důležité je, že klient i server spouštějí každý vlastní kopii modulu, takže hráč, který si ceny změnil na svém zařízení, na serveru nic nezmění.
Krok 3: Stavíme GUI obchodu
Tento LocalScript postaví celé okno v kódu: tlačítko Shop, panel s posuvnou mřížkou karet, jedno tlačítko Buy na každý předmět katalogu, počítadlo Coins a řádek stavu pro odpovědi serveru. Protože je všechno udělané kódem, stačí ho vložit a kliknout na Play. Tabulka za ním vypisuje každý objekt, pokud chcete okno rozvrhnout ručně.
- V Exploreru rozbalte StarterPlayer, najeďte myší na StarterPlayerScripts a vložte LocalScript s názvem
ShopClient. - Nahraďte jeho obsah kódem níže.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Co vrací modul ShopCatalog, aby přísná kontrola typů kontrolovala pole, která používáme
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: drží všechno, co obchod kreslí na obrazovku hráče
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- obchod zůstane, když se postava respawne
-- Tlačítko u levého okraje, které obchod otevírá a zavírá
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)
-- Okno obchodu: uprostřed, skryté, dokud ho hráč neotevře
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) -- nedovolí oknu na velkých obrazovkách být obrovské
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
-- Tady se ukazují odpovědi serveru, například "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: oblast, která se posouvá, když je karet víc, než se vejde
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() -- začíná od nuly; AutomaticCanvasSize ho roztáhne podle karet
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel
-- UIGridLayout: rozkládá karty do řad a zalamuje je na další řadu
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..."
-- Posíláme jen id předmětu. Cenu si server najde sám.
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)
-- Server tento atribut nastaví, když nákup prošel (nebo když se načetly uložené předměty)
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")
-- Ukazujeme mince hráče. Skutečnou hodnotu má server; tady se jen zobrazuje.
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()
Tlačítka používají Activated, ne MouseButton1Click: spustí se kliknutím myši, dotykem na telefonu i tlačítkem A nebo křížkem na gamepadu.
Definice type nahoře popisují, co vrací ShopCatalog, aby přísná kontrola typů chytila překlep v poli, například item.prise. Když hra běží, nic nemění.
| Objekt | Úkol v obchodě | Hlavní vlastnosti |
|---|---|---|
ScreenGui | Drží všechno nakreslené na obrazovce | ResetOnSpawn false, aby obchod přežil respawn |
Frame | Okno a každá karta předmětu | AnchorPoint 0.5, 0.5 a Position 0.5, 0.5, aby bylo okno uprostřed |
UISizeConstraint | Omezuje okno na velkých obrazovkách | MaxSize 640 na 460 |
ScrollingFrame | Posouvá se, když je karet víc, než se vejde | CanvasSize 0 a AutomaticCanvasSize Y, aby posuvná oblast rostla s kartami |
UIGridLayout | Staví karty do řad a zalamuje je | CellSize 180 na 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | Zaobluje rohy | CornerRadius od 8 do 14 pixelů |
UIPadding | Vnitřní odsazení | Od 10 do 12 pixelů z každé strany |
TextButton | Tlačítka Shop, zavření a Buy | Událost Activated |
Pokud chcete okno nakreslit ručně, postavte stejné objekty ve StarterGui s těmito vlastnostmi, i tam nastavte ResetOnSpawn u ScreenGui na false a nechte jednu kartu jako šablonu, kterou LocalScript naklonuje pro každý předmět katalogu. Skript pak jen vyplní karty a připojí tlačítka. Logika nákupu v dalším kroku se nemění.
Pokud vaše hra začíná hlavním menu, v tom návodu je jeden řádek, který přidáte do ShopClient, aby se tlačítko Shop objevilo až poté, co hráč klikne na Play. Aby se obchod otevíral rozhovorem s prodavačem, návod k dialogům s NPC ukazuje, jak přidat akci OpenShop, která ShopClient řekne, ať okno otevře, a nákupy přitom dál procházejí kontrolami obchodu na serveru.
Krok 4: Kontrola a nákup na serveru
Tento Script je jediné místo, kde nákup může proběhnout. Dostane id předmětu, ověří ho, najde cenu, zkontroluje Coins hráče, pak strhne mince a vydá Tool. Tlačítku Buy odpoví true nebo false a zprávou k zobrazení.
Najeďte myší na ServerScriptService, vložte Script s názvem ShopService a vložte do něj toto:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Co vrací modul ShopCatalog, aby přísná kontrola typů kontrolovala pole, která používáme
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: hráč může nástroj použít hned
local backpack = player:FindFirstChildOfClass("Backpack")
if backpack then
template:Clone().Parent = backpack
end
-- StarterGear: Roblox ho při každém objevení postavy znovu zkopíruje do Backpacku
local starterGear = player:FindFirstChildOfClass("StarterGear")
if starterGear then
template:Clone().Parent = starterGear
end
end
local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
-- 1. Klient posílá jen id předmětu, takže to musí být řetězec
if type(itemId) ~= "string" then
return false, "That item does not exist."
end
-- 2. Ignorujeme dvojklik a záplavy požadavků ze skriptů
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. Hledáme předmět ve vlastní kopii katalogu na serveru
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. Cena se bere z katalogu a nikdy od klienta
if coins.Value < item.price then
return false, `You need {item.price - coins.Value} more coins.`
end
-- 5. Strhneme mince, pak vydáme předmět. Nic tady nepozastavuje běh, takže dva požadavky
-- od jednoho hráče nemohou oba projít kontrolami výše, dokud se tohle neprovede.
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)
Vlastnictví se ukládá jako atribut Player, například Owns_sword. Atributy nastavené serverem se replikují na zařízení hráče, takže LocalScript může kartu přepnout na "Owned". Změna, kterou hráč udělá ve své kopii, se na server nedostane.
Tool se dostane na dvě místa. Kopie v Backpacku se hned objeví v hotbaru. Kopii ve StarterGear Roblox dá do nového Backpacku pokaždé, když se objeví postava. Bez ní by koupený předmět zmizel hned při první smrti hráče.
Proč klient nikdy neposílá cenu
Všechno, co je na zařízení hráče, může tento hráč změnit. Podvodníci spouštějí vlastní kód ve své kopii hry: mohou číst vaše LocalScripty, měnit GUI a volat BuyItem:InvokeServer() s jakýmikoli argumenty, kolikrát chtějí. Návod Robloxu k bezpečnosti říká kontrolovat typ i hodnotu všeho, co remote dostane, a jako příklad tam slouží právě obchod.
| Podvodník pošle | Kdyby mu server věřil | Co dělá ShopService |
|---|---|---|
| Cenu 0 | Všechny předměty zdarma | Ignoruje ji. Cena se bere z katalogu. |
| Cenu -1000 | Coins.Value -= -1000 mu dá 1 000 mincí | Ignoruje ji. |
NaN místo ceny | Každé porovnání s NaN je nepravdivé, takže kontrola „nemá dost mincí“ se nikdy nespustí | Ignoruje ji. |
| Id, které v katalogu není, nebo tabulku místo řetězce | Chyby ve skriptu nebo předměty, které jste prodávat nechtěli | Odpoví "That item does not exist." |
| Stovky požadavků za sekundu | Zátěž serveru a každá díra v kontrolách se spustí stokrát | Zpracuje nejvýš jeden požadavek od hráče za půl sekundy. |
| Coins změněné na své obrazovce | Nákupy za mince, které nemá | Vůbec to nevidí. Server čte jen svou hodnotu Coins. |
Toto pravidlo platí pro každý remote, který píšete: posílejte to, co hráč vybral, například id předmětu nebo číslo slotu, a nikdy to, kolik to stojí nebo co má dostat. Návod k RemoteEvent kontrolu argumentů remotu rozebírá podrobněji.
Krok 5: Testujeme obchod
- Klikněte na Play. Vlevo se objeví tlačítko Shop. Otevřete ho a kupte Flashlight: Coins se sníží o 25, nástroj se objeví v hotbaru a jeho tlačítko se změní na Owned.
- Zkuste Speed Coil, který stojí 300. Řádek stavu napíše, kolik mincí ještě chybí, a nic se nestrhne.
- Resetujte postavu přes herní menu. Flashlight se díky kopii ve StarterGear vrátí do nového Backpacku.
- Chcete-li si během testu přidat mince, klikněte na přepínač Client/Server a přejděte na Server, najděte v Exploreru
Players, své jméno,leaderstats,Coinsa změňte jeho Value v okně Properties. Totéž v režimu Client změní jen vaši obrazovku a je to přesně ten druh změny, který server ignoruje.
Pokud tlačítko odpoví "The shop did not answer", otevřete okno Output přes menu Window ve Studiu a najděte červenou chybu od ShopService. Pokud ale tlačítko visí na "Buying...", ShopService neběží nebo uvízl při čekání na objekt: viz časté chyby.
Prodej gamepassu za Robux
Mince jsou vaše vlastní měna, takže obchod výše rozhoduje o každém nákupu sám. Co hráč kupuje za Robux, funguje jinak: gamepass se kupuje jednou a zůstává navždy (VIP bonusy, trvalý nástroj) a developer product se dá kupovat znovu a znovu (balík mincí, přeskočení levelu). Obojí jde přes MarketplaceService od Robloxu a platbu přijímá Roblox, ne váš skript.
Z tohoto návodu se přenášejí dvě pravidla: okno nákupu spouštějte tlačítkem na klientu a bonus vydávejte jen na serveru, když Roblox nákup potvrdil nebo hráč pass už má. Návod ke skriptu gamepassu to staví celé: kontrolu vlastnictví při vstupu, okno nákupu, bonusy jako VIP dveře a kdy je místo passu lepší developer product. Při volbě ceny vám bezplatná kalkulačka poplatku z Robux ukáže, kolik vám pass nebo developer product vynese po podílu Robloxu.
Ukládáme nákupy hráčů
Všechno, co jsme udělali, žije jednu relaci: mince a koupené předměty se vynulují, když hráč odejde, dokud je neuložíte přes úložiště dat. Abychom tu kód ukládání neopakovali, projděte tutoriál k DataStore (nebo krok 3 návodu k leaderboardu, tam je kratší verze) a pamatujte na pravidla obchodu:
- Ukládejte id předmětů, například
{ "sword", "flashlight" }, ve stejné tabulce jako hodnotu Coins, aby jedno uložení zapsalo utracené mince i koupený předmět. Tool a jiné instance do úložiště dat dát nejdou. - Když se data načtou, projděte uložená id, přeskočte ta, která už v katalogu nejsou, nastavte každý atribut
Owns_a vydejte Tool stejně, jako to dělágiveTool. Okno obchodu se aktualizuje samo, protože tyto atributy poslouchá. - Vlastnictví passu ukládat nemusíte:
UserOwnsGamePassAsyncse zeptá Robloxu pokaždé, když hráč přijde. - Nikdy neukládejte hráče, jehož data se nenačetla, jinak neúspěšné načtení může jeho nákupy nahradit prázdným seznamem.
Časté chyby a řešení
Když se obchod chová divně, zkontrolujte nejdřív tohle. Jako první otevřete okno Output (menu Window, pak Output): chyba skriptu uvádí skript i řádek.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'
Skript čeká na objekt, který pod tímto přesným názvem neexistuje. Zkontrolujte pravopis a velká písmena u ShopRemotes, BuyItem, ShopCatalog a ShopItems a to, že ShopItems leží ve ServerStorage, ne v ReplicatedStorage. Návod k chybám ve skriptech toto varování podrobně rozebírá.
Tlačítko Buy visí na "Buying..." a neodpovídá
Na serveru nikdo nenastavil BuyItem.OnServerInvoke, takže Roblox požadavek drží, dokud se to nestane. Ujistěte se, že ShopService je Script, ne LocalScript, a leží v ServerScriptService, a hledejte v Output varování Infinite yield possible od ShopService: znamená, že skript uvízl při čekání na ShopCatalog, ShopRemotes nebo ShopItems.
Tlačítko Buy píše "The shop did not answer"
Volání serveru spadlo, místo aby vrátilo odpověď. Obvyklá příčina je chyba uvnitř ShopService při zpracování požadavku, proto najděte v Output červenou chybu od ShopService: je v ní uvedený řádek.
Tlačítko píše "This item is not available right now"
Server nenašel Tool s toolName tohoto předmětu uvnitř ServerStorage, ShopItems. V Output je varování s přesným názvem, který hledal.
Koupil jsem nástroj, ale postava ho neumí držet nebo uvízne
Tool musí mít přímo uvnitř přesně jeden part s názvem Handle a žádný z jeho partů nesmí být ukotvený. U nástroje, který se nemusí držet v ruce, místo toho odškrtněte RequiresHandle.
Mince se snížily na mé obrazovce, ale ne u ostatních
Nákup proběhl v LocalScriptu, takže se změnilo jen vaše zařízení. Přesuňte strhávání mincí a vydání Toolu do serverového Scriptu, jako v kroku 4.
Koupené předměty po novém připojení zmizí
Zatím se nic neukládá. Viz ukládání nákupů.
Udělat s RoCode
Pokud se vám to všechno nechce stavět ručně, RoCode to může udělat ve vašem otevřeném place. Je to nezávislý AI agent pro kód: funkci popíšete v jeho webovém chatu a jeho plugin pro Roblox Studio vytvoří skripty, remote a GUI ve vašem Exploreru, takže kód z okna chatu kopírovat nemusíte.
Přidej obchod za mince: tlačítko Shop, které otevře mřížku čtyř nástrojů s cenami v Coins z mých leaderstats. Server má kontrolovat cenu a vydávat nástroj do Backpacku a StarterGear.
- Může si prohlédnout váš place přes Search Scripts a Read Script kvůli existujícím leaderstats a kódu obchodu, aby použil vaši hodnotu Coins a nepřidával druhou
- Umí postavit kostru okna přes Build UI: šablona obchodu přichází se zástupnými kartami a LocalScriptem pro efekty při najetí myší a tlačítko Close; logika nákupu se píše samostatnými skripty
- Vytvoří RemoteFunction přes Create Instance a napíše ModuleScript katalogu, serverový Script a LocalScript přes Create Script
- Ověří kompilaci každého skriptu ve Studiu přes Check Script (typy nekontroluje a skripty nespouští) a každá dávka změn je bod pro vrácení ve Studiu
Passy musíte stejně vytvořit v Creator Hubu sami, protože RoCode neumí vytvářet passy ani developer products, a nákupy také testujete vy: s pluginem 3.9 nebo novějším může RoCode spustit krátký playtest a přečíst chyby a s pluginem 3.9.15 nebo novějším jeho testovací postava umí mačkat tlačítka Shop a Buy, ale kontroluje jen to, co se sám rozhodl otestovat. Obchod obvykle přichází po hlavní hratelnosti a ukládání; postupná smyčka tvorby hry s RoCode ukazuje, kam patří. Jak se RoCode připojuje ke Studiu.
Časté otázky
Co je lepší pro tlačítko Buy v Robloxu: RemoteEvent, nebo RemoteFunction?
Poslouží obojí, pokud kontroluje server. RemoteFunction umožní tlačítku počkat na odpověď serveru a ukázat ji, proto ji návod používá, a příklad obchodu v návodu Robloxu k bezpečnosti je také na RemoteFunction. Volejte ji jen z klienta: server, který volá InvokeClient, může čekat věčně, pokud klient nikdy neodpoví. Návod k RemoteEvent obě možnosti porovnává.
Jak otevřít obchod přes NPC místo tlačítka?
Dejte ProximityPrompt do nějakého partu NPC, například do jeho HumanoidRootPart, poslouchejte jeho událost Triggered v serverovém Scriptu a pošlete tomuto hráči RemoteEvent, aby LocalScript ukázal panel. Pokud se má nakupovat jen u NPC, kontrolujte vzdálenost od NPC i uvnitř handleru BuyItem, protože klient může remote zavolat odkudkoli.
Jak prodávat předměty, které se dají koupit víckrát?
U takových předmětů vynechte kontrolu „už má“ a nevydávejte Tool, ale něco, co se dá počítat, například přičtěte 1 k IntValue, který počítá lektvary. Hledání ceny a kontrolu mincí nechte, jak jsou.
Proč obchod zmizí, když se postava respawne?
Jeho ScreenGui má ResetOnSpawn nastavené na true, což je výchozí hodnota, takže ho Roblox při respawnu smaže. Nastavte false, jak to dělá skript v kroku 3.
Můžu vzít bezplatnou šablonu GUI obchodu?
Ano, poslouží jakékoli rozvržení, pokud jeho tlačítka Buy posílají jen id předmětu a samotný nákup probíhá v serverovém Scriptu jako ShopService. Než šablonu vezmete, zkontrolujte, jestli se mince nestrhávají nebo předměty nevydávají v LocalScriptu.
Zdroje a další čtení
- Roblox Creator Docs: Securing the client-server boundary (anglicky). kontrola argumentů remotů, NaN, omezení četnosti a příklad herního obchodu
- Roblox Creator Docs: Remote events and callbacks (anglicky). RemoteFunction, InvokeServer, OnServerInvoke a rizika InvokeClient
- Roblox Creator Docs: Passes (anglicky). vytváření a prodej passů, UserOwnsGamePassAsync a PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (anglicky). herní Shop, který Roblox vytváří automaticky
- Roblox Creator Docs: Developer Products (anglicky). opakované nákupy za Robux a ProcessReceipt
- Roblox Creator Docs: StarterGear (anglicky). proč se Tool ve StarterGear po respawnu vrátí
- Roblox Creator Docs: In-game tools (anglicky). Handle, ukotvení a RequiresHandle
Jak byl kód ověřen: každý skript na této stránce prochází přísnou kontrolou typů Luau s definicemi Roblox API (luau-lsp, 20. listopadu 2026). Kontrola typů zachytí chyby v názvech API a špatné typy, ale ne chyby v herní logice, proto vše otestujte ve Studiu před publikováním.