Pe scurt
Ține obiectele și prețurile într-un ModuleScript din ReplicatedStorage, construiește fereastra din ScreenGui, ScrollingFrame și UIGridLayout și lasă fiecare buton Buy să apeleze o RemoteFunction, transmițând doar id-ul obiectului. Mai departe, un Script în ServerScriptService găsește singur prețul, verifică și scade Coins-ul jucătorului și dă obiectul.
- Nu lăsa niciodată clientul să trimită prețul. Oricine îți poate declanșa remote-urile cu orice valori, așa că serverul ia prețul din propria copie a catalogului.
- Dă Tool-ul cumpărat clonându-l din ServerStorage în Backpack-ul jucătorului (ca să-l folosească imediat) și în StarterGear (ca să revină după respawn).
- Ce se vinde pe Robux sunt pass-uri și developer products, cu care lucrează MarketplaceService. Pentru ele, Roblox creează și singur un Shop, iar acesta nu e același lucru cu un magazin pe monede.
Pe această pagină
Cum e construit un magazin funcțional
Un magazin care funcționează într-un joc real e împărțit între dispozitivul jucătorului și server. Dispozitivul desenează fereastra și spune "vreau să cumpăr sabia". Serverul, singura parte în care poți avea încredere, decide dacă asta se întâmplă. Scripturile de magazin care "nu merg" sau pe care jucătorii le strică prin trișare iau adesea această decizie pe partea greșită.
| Parte | Unde se află | Ce face |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | Id-urile obiectelor, numele, prețurile și Tool-ul pe care îl dă fiecare. Îl citesc ambele părți. |
RemoteFunction BuyItem | ReplicatedStorage, în folderul ShopRemotes | Duce cererea de cumpărare la server și răspunsul înapoi. |
LocalScript ShopClient | StarterPlayerScripts | Construiește fereastra magazinului și trimite id-ul obiectului când e apăsat un buton Buy. |
Script ShopService | ServerScriptService | Verifică cererea, scade Coins și dă Tool-ul. |
| Tool-urile pe care le vinzi | ServerStorage, în folderul ShopItems | Originalele pe care le copiază serverul. Nimic din ServerStorage nu se trimite jucătorilor. |
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
Pasul 1: monedele și obiectele de vânzare
Magazinul cheltuie valoarea Coins din leaderstats-ul jucătorului. Dacă ai parcurs ghidul despre clasament, o ai deja și poți sări peste acest script. Altfel inserează un Script în ServerScriptService cu numele Leaderstats. Îi dă fiecăruia 200 de monede la start, ca să poți testa imediat cumpărăturile.
local Players = game:GetService("Players")
local STARTING_COINS = 200 -- ajunge pentru testarea magazinului; pune 0 când jucătorii vor putea câștiga monede
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
Ține un singur script de leaderstats. Două scripturi care creează fiecare un folder leaderstats îi dau fiecărui jucător două foldere, iar magazinul îl poate citi pe cel greșit.
Apoi creează obiectele pe care le caută scripturile. Majusculele din nume contează, așa că scrie-le exact ca aici.
- În Explorer treci cu mouse-ul peste ReplicatedStorage, apasă butonul + și inserează un Folder numit
ShopRemotes. În el inserează o RemoteFunction numităBuyItem. - Treci cu mouse-ul peste ServerStorage și inserează un Folder numit
ShopItems. - Pune în ShopItems câte un Tool pentru fiecare obiect, cu numele
ClassicSword,Flashlight,GrappleHookșiSpeedCoil. Pentru primul test, un Tool are nevoie doar de un Part neancorat numitHandle. Merge și orice Tool pe care îl ai deja: dă-i numele potrivit. O armă care chiar dă daune construiește după ghidul despre sabie sau ghidul despre arme; fiecare spune cum o legi de catalog. - Selectează fiecare Tool și debifează CanBeDropped în fereastra Properties. Cât e bifat, apăsarea Backspace aruncă instrumentul în Workspace, iar orice jucător poate ridica ce a plătit cumpărătorul.
Poți începe și cu un singur Tool. Dacă lipsește Tool-ul unui obiect, serverul refuză să vândă acel obiect și scrie un avertisment cu numele lui, așa că jucătorului nu i se ia nimic.
Pasul 2: obiectele și prețurile în catalog
Catalogul e singura listă cu tot ce vinde magazinul. LocalScript-ul îl citește ca să deseneze cardurile, iar serverul îl citește ca să găsească prețurile, așa că schimbarea unui preț înseamnă o singură editare într-un singur loc.
Treci cu mouse-ul peste ReplicatedStorage, inserează un ModuleScript, redenumește-l în ShopCatalog și înlocuiește-i conținutul cu asta:
export type ShopItem = {
id: string, -- se salvează apoi în depozitul de date: nu-l schimba când obiectul e deja la jucători
name: string, -- apare pe card; se poate schimba
price: number, -- în Coins
description: string,
toolName: string, -- Tool-ul din ServerStorage.ShopItems pe care îl primește jucătorul
}
-- Cardurile apar în această ordine
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
-- Returnează obiectul cu acest id sau nil dacă nu există un astfel de obiect
function ShopCatalog.get(id: string): ShopItem?
return byId[id]
end
-- Atributul Player pe care serverul îl setează la true când jucătorul are obiectul
function ShopCatalog.ownedAttribute(id: string): string
return "Owns_" .. id
end
return ShopCatalog
Fiecare obiect are un id și, separat, un name afișat. Serverul scrie tocmai id-ul când jucătorul are ceva, așa că "Classic Sword" poate fi redenumit mai târziu fără să strice cumpărăturile salvate. Descrierile sunt doar text pe card; ce face Tool-ul decid propriile lui scripturi.
Jucătorii pot citi un ModuleScript din ReplicatedStorage, așa că aceste prețuri sunt publice. E în regulă: oricum sunt scrise pe carduri. Ce contează e că clientul și serverul rulează fiecare propria copie a modulului, așa că un jucător care a schimbat prețurile pe dispozitivul lui nu schimbă nimic pe server.
Pasul 3: construim GUI-ul magazinului
Acest LocalScript construiește toată fereastra în cod: butonul Shop, panoul cu grila derulabilă de carduri, câte un buton Buy pentru fiecare obiect din catalog, un contor de Coins și un rând de stare pentru răspunsurile serverului. Pentru că totul e făcut din cod, îl poți lipi și apăsa Play. Tabelul de după el enumeră fiecare obiect, dacă vrei să așezi fereastra manual.
- În Explorer deschide StarterPlayer, treci cu mouse-ul peste StarterPlayerScripts și inserează un LocalScript numit
ShopClient. - Înlocuiește-i conținutul cu codul de mai jos.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Ce returnează modulul ShopCatalog, ca verificarea strictă de tipuri să verifice câmpurile pe care le folosim
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: ține tot ce desenează magazinul pe ecranul jucătorului
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- magazinul rămâne când personajul face respawn
-- Butonul de la marginea din stânga care deschide și închide magazinul
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)
-- Fereastra magazinului: în centru, ascunsă până o deschide jucătorul
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) -- împiedică fereastra să devină uriașă pe ecranele mari
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
-- Aici apar răspunsurile serverului, de exemplu "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: zona care se derulează când sunt mai multe carduri decât încap
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() -- pornește de la zero; AutomaticCanvasSize o întinde după carduri
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel
-- UIGridLayout: așază cardurile pe rânduri și le mută pe rândul următor
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..."
-- Trimitem doar id-ul obiectului. Prețul îl găsește singur serverul.
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)
-- Serverul setează acest atribut când cumpărarea a reușit (sau când s-au încărcat obiectele salvate)
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")
-- Arătăm monedele jucătorului. Valoarea reală e la server; aici doar se afișează.
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()
Butoanele folosesc Activated, nu MouseButton1Click: se declanșează la un clic de mouse, la o atingere pe telefon și la butonul A sau X de pe gamepad.
Definițiile type de sus descriu ce returnează ShopCatalog, ca verificarea strictă de tipuri să prindă o greșeală de tastare într-un câmp, de exemplu item.prise. Când jocul rulează, nu schimbă nimic.
| Obiect | Sarcina în magazin | Proprietățile principale |
|---|---|---|
ScreenGui | Ține tot ce e desenat pe ecran | ResetOnSpawn false, ca magazinul să supraviețuiască unui respawn |
Frame | Fereastra și fiecare card de obiect | AnchorPoint 0.5, 0.5 și Position 0.5, 0.5, ca fereastra să fie în centru |
UISizeConstraint | Limitează fereastra pe ecranele mari | MaxSize 640 pe 460 |
ScrollingFrame | Se derulează când sunt mai multe carduri decât încap | CanvasSize 0 și AutomaticCanvasSize Y, ca zona derulabilă să crească odată cu cardurile |
UIGridLayout | Pune cardurile pe rânduri și le mută pe rândul următor | CellSize 180 pe 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | Rotunjește colțurile | CornerRadius de la 8 la 14 pixeli |
UIPadding | Margini interioare | De la 10 la 12 pixeli pe fiecare latură |
TextButton | Butoanele Shop, de închidere și Buy | Evenimentul Activated |
Dacă vrei să desenezi fereastra manual, construiește aceleași obiecte în StarterGui cu aceste proprietăți, setează și acolo ResetOnSpawn-ul ScreenGui-ului la false și lasă un card ca șablon, pe care LocalScript-ul îl clonează pentru fiecare obiect din catalog. Atunci scriptul doar completează cardurile și conectează butoanele. Logica de cumpărare din pasul următor nu se schimbă.
Dacă jocul tău începe cu un meniu principal, acel ghid are un rând de adăugat în ShopClient, ca butonul Shop să apară doar după ce jucătorul a apăsat Play. Ca magazinul să se deschidă vorbind cu un vânzător, ghidul despre dialoguri cu NPC arată cum adaugi o acțiune OpenShop care îi spune lui ShopClient să deschidă fereastra, iar cumpărăturile trec tot prin verificările magazinului pe server.
Pasul 4: verificarea și cumpărarea pe server
Acest Script e singurul loc în care poate avea loc o cumpărare. Primește id-ul obiectului, îl verifică, găsește prețul, verifică Coins-ul jucătorului, apoi scade monedele și dă Tool-ul. Butonului Buy îi răspunde cu true sau false și cu un mesaj de afișat.
Treci cu mouse-ul peste ServerScriptService, inserează un Script numit ShopService și lipește în el asta:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Ce returnează modulul ShopCatalog, ca verificarea strictă de tipuri să verifice câmpurile pe care le folosim
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: jucătorul poate folosi imediat instrumentul
local backpack = player:FindFirstChildOfClass("Backpack")
if backpack then
template:Clone().Parent = backpack
end
-- StarterGear: Roblox îl copiază din nou în Backpack la fiecare apariție a personajului
local starterGear = player:FindFirstChildOfClass("StarterGear")
if starterGear then
template:Clone().Parent = starterGear
end
end
local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
-- 1. Clientul trimite doar id-ul obiectului, deci trebuie să fie un șir
if type(itemId) ~= "string" then
return false, "That item does not exist."
end
-- 2. Ignorăm dublele clicuri și șuvoaiele de cereri din scripturi
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. Căutăm obiectul în propria copie a catalogului de pe server
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. Prețul vine din catalog și niciodată de la client
if coins.Value < item.price then
return false, `You need {item.price - coins.Value} more coins.`
end
-- 5. Scădem monedele, apoi dăm obiectul. Aici nimic nu cedează execuția, așa că două cereri
-- de la același jucător nu pot trece amândouă de verificările de mai sus înainte să se execute asta.
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)
Proprietatea se ține ca atribut al Player, de exemplu Owns_sword. Atributele setate de server se replică pe dispozitivul jucătorului, așa că LocalScript-ul poate trece cardul pe "Owned". O schimbare pe care jucătorul o face în copia lui nu ajunge la server.
Tool-ul ajunge în două locuri. Copia din Backpack apare imediat în hotbar. Copia din StarterGear o pune Roblox într-un Backpack nou de fiecare dată când apare personajul. Fără ea, obiectul cumpărat ar dispărea la prima moarte a jucătorului.
De ce clientul nu trimite niciodată prețul
Tot ce e pe dispozitivul jucătorului poate fi schimbat de acel jucător. Trișorii își rulează propriul cod în copia lor a jocului: îți pot citi LocalScript-urile, pot schimba GUI-ul și pot apela BuyItem:InvokeServer() cu orice argumente, de oricâte ori. Ghidul de securitate Roblox spune să verifici atât tipul, cât și valoarea a tot ce primește un remote, iar exemplul de acolo e chiar un magazin.
| Trișorul trimite | Dacă serverul l-ar crede | Ce face ShopService |
|---|---|---|
| Prețul 0 | Toate obiectele sunt gratuite | Îl ignoră. Prețul vine din catalog. |
| Prețul -1000 | Coins.Value -= -1000 îi dă 1 000 de monede | Îl ignoră. |
NaN în loc de preț | Orice comparație cu NaN e falsă, așa că verificarea "nu ajung monedele" nu se declanșează niciodată | Îl ignoră. |
| Un id care nu e în catalog sau un tabel în loc de șir | Erori în script sau obiecte pe care nu voiai să le vinzi | Răspunde "That item does not exist." |
| Sute de cereri pe secundă | Încărcarea serverului, iar orice gaură în verificări se declanșează de sute de ori | Tratează cel mult o cerere de la un jucător la fiecare jumătate de secundă. |
| Coins schimbat pe propriul ecran | Cumpărături cu monede pe care nu le are | Nu vede deloc asta. Serverul citește doar propria valoare Coins. |
Regula asta se potrivește fiecărui remote pe care îl scrii: trimite ce a ales jucătorul, de exemplu id-ul obiectului sau numărul slotului, și niciodată cât costă sau ce ar trebui să primească. Ghidul despre RemoteEvent explică mai pe larg verificarea argumentelor unui remote.
Pasul 5: testăm magazinul
- Apasă Play. În stânga apare butonul Shop. Deschide-l și cumpără Flashlight: Coins scade cu 25, instrumentul apare în hotbar, iar butonul lui devine Owned.
- Încearcă Speed Coil, care costă 300. Rândul de stare scrie câte monede îți mai lipsesc și nu se ia nimic.
- Resetează-ți personajul din meniul din joc. Flashlight revine în noul Backpack datorită copiei din StarterGear.
- Ca să-ți adaugi monede în timpul testului, apasă comutatorul Client/Server și treci pe Server, găsește în Explorer
Players, numele tău,leaderstats,Coinsși schimbă-i Value în fereastra Properties. Același lucru în modul Client schimbă doar ecranul tău, și e exact genul de schimbare pe care serverul o ignoră.
Dacă butonul răspunde "The shop did not answer", deschide fereastra Output din meniul Window din Studio și găsește eroarea roșie de la ShopService. Dacă butonul rămâne la "Buying...", înseamnă că ShopService nu rulează sau s-a blocat așteptând un obiect: vezi erorile frecvente.
Vânzarea unui gamepass pe Robux
Monedele sunt propria ta monedă, așa că magazinul de mai sus decide singur fiecare cumpărare. Ce cumpără jucătorul pe Robux funcționează altfel: un gamepass se cumpără o dată și rămâne pentru totdeauna (bonusuri VIP, un instrument permanent), iar un developer product se poate cumpăra iar și iar (un pachet de monede, sărirea unui nivel). Amândouă trec prin MarketplaceService-ul Roblox, iar plata o primește Roblox, nu scriptul tău.
Din acest ghid se transferă două reguli: pornește fereastra de cumpărare cu un buton pe client, iar bonusul dă-l doar pe server, când Roblox a confirmat cumpărarea sau jucătorul are deja pass-ul. Ghidul despre scriptul de gamepass construiește asta complet: verificarea proprietății la intrare, fereastra de cumpărare, bonusuri precum o ușă VIP și când e mai bun un developer product în locul unui pass. Ca să alegi prețul, calculatorul gratuit de comision Robux arată cât îți aduce un pass sau un developer product după partea Roblox.
Salvăm cumpărăturile jucătorilor
Tot ce am făcut trăiește o sesiune: monedele și obiectele cumpărate se resetează când jucătorul iese, până nu le salvezi printr-un depozit de date. Ca să nu repetăm aici codul de salvare, parcurge tutorialul DataStore (sau pasul 3 din ghidul despre clasament, unde e o versiune mai scurtă) și ține minte regulile magazinului:
- Salvează id-urile obiectelor, de exemplu
{ "sword", "flashlight" }, în același tabel ca valoarea Coins, ca o singură salvare să scrie atât monedele cheltuite, cât și obiectul cumpărat. Un Tool și alte instance-uri nu pot fi puse într-un depozit de date. - Când datele s-au încărcat, parcurge id-urile salvate, sari peste cele care nu mai sunt în catalog, setează fiecare atribut
Owns_și dă Tool-ul la fel cum facegiveTool. Fereastra magazinului se actualizează singură, pentru că ascultă aceste atribute. - Proprietatea unui pass nu trebuie salvată:
UserOwnsGamePassAsyncîntreabă Roblox de fiecare dată când intră jucătorul. - Nu salva niciodată un jucător ale cărui date nu s-au încărcat, altfel o încărcare eșuată îi poate înlocui cumpărăturile cu o listă goală.
Erori frecvente și soluții
Când magazinul se poartă ciudat, verifică întâi asta. Mai întâi deschide fereastra Output (meniul Window, apoi Output): o eroare de script numește scriptul și rândul.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'
Scriptul așteaptă un obiect care nu există sub exact acest nume. Verifică scrierea și majusculele la ShopRemotes, BuyItem, ShopCatalog și ShopItems și dacă ShopItems stă în ServerStorage, nu în ReplicatedStorage. Ghidul despre erorile din scripturi explică în detaliu acest avertisment.
Butonul Buy rămâne la "Buying..." și nu răspunde
Pe server nimeni nu a setat BuyItem.OnServerInvoke, așa că Roblox ține cererea până se întâmplă asta. Asigură-te că ShopService e un Script, nu un LocalScript, și stă în ServerScriptService și caută în Output un avertisment Infinite yield possible de la ShopService: înseamnă că scriptul s-a blocat așteptând ShopCatalog, ShopRemotes sau ShopItems.
Butonul Buy scrie "The shop did not answer"
Apelul către server a căzut, nu a returnat un răspuns. Cauza obișnuită e o eroare în ShopService în timpul tratării cererii, așa că găsește în Output eroarea roșie de la ShopService: în ea e indicat rândul.
Butonul scrie "This item is not available right now"
Serverul nu a găsit un Tool cu toolName-ul acestui obiect în ServerStorage, ShopItems. În Output e un avertisment cu numele exact pe care l-a căutat.
Am cumpărat un instrument, dar personajul nu-l poate ține sau rămâne blocat
Tool-ul trebuie să aibă exact un part numit Handle direct în el, iar niciun part al lui nu trebuie să fie ancorat. Pentru un instrument care nu trebuie ținut în mână, debifează în schimb RequiresHandle.
Monedele au scăzut pe ecranul meu, dar nu și la ceilalți
Cumpărarea s-a făcut într-un LocalScript, așa că s-a schimbat doar dispozitivul tău. Mută scăderea monedelor și darea Tool-ului într-un Script de server, ca la pasul 4.
Obiectele cumpărate dispar după reintrare
Deocamdată nu se salvează nimic. Vezi salvarea cumpărăturilor.
Fă-o cu RoCode
Dacă nu ai chef să construiești toate astea manual, RoCode le poate face în place-ul pe care îl ai deschis. E un agent AI independent pentru cod: descrii funcția în chatul lui web, iar pluginul lui pentru Roblox Studio creează scripturile, remote-ul și GUI-ul în Explorer-ul tău, așa că nu trebuie să copiezi cod din fereastra de chat.
Adaugă un magazin pe monede: un buton Shop care deschide o grilă cu patru instrumente, cu prețuri în Coins din leaderstats-ul meu. Serverul trebuie să verifice prețul și să dea instrumentul în Backpack și StarterGear.
- Se poate uita prin place-ul tău cu Search Scripts și Read Script după leaderstats și cod de magazin existente, ca să-ți folosească valoarea Coins în loc să adauge a doua
- Poate construi o schiță a ferestrei prin Build UI: șablonul de magazin vine cu carduri provizorii și un LocalScript pentru efectele de hover și butonul Close; logica de cumpărare se scrie în scripturi separate
- Creează RemoteFunction-ul prin Create Instance și scrie ModuleScript-ul catalogului, Script-ul de server și LocalScript-ul prin Create Script
- Verifică în Studio compilarea fiecărui script prin Check Script (nu verifică tipurile și nu rulează scripturile), iar fiecare lot de modificări e un punct de anulare în Studio
Pass-urile tot tu trebuie să le creezi în Creator Hub, pentru că RoCode nu știe să creeze pass-uri și developer products, iar cumpărăturile tot tu le testezi: cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.15 sau mai nou personajul lui de test poate apăsa butoanele Shop și Buy, dar verifică doar ce a hotărât el să testeze. Magazinul vine de obicei după gameplay-ul principal și salvare; bucla pas cu pas de creare a unui joc cu RoCode arată unde îi e locul. Cum se conectează RoCode la Studio.
Întrebări frecvente
Ce e mai bun pentru butonul Buy în Roblox: RemoteEvent sau RemoteFunction?
Merg amândouă, dacă verifică serverul. O RemoteFunction îi permite butonului să aștepte răspunsul serverului și să-l arate, de aceea ghidul o folosește, iar în ghidul de securitate Roblox exemplul de magazin e tot pe RemoteFunction. Apeleaz-o doar de pe client: un server care apelează InvokeClient poate aștepta la nesfârșit dacă clientul nu răspunde niciodată. Ghidul despre RemoteEvent compară cele două variante.
Cum deschid magazinul printr-un NPC, nu cu un buton?
Pune un ProximityPrompt într-un part al NPC-ului, de exemplu în HumanoidRootPart-ul lui, ascultă-i evenimentul Triggered într-un Script de server și trimite-i acelui jucător un RemoteEvent, ca LocalScript-ul să arate panoul. Dacă se poate cumpăra doar lângă NPC, verifică și distanța până la NPC în handler-ul BuyItem, pentru că clientul poate declanșa remote-ul de oriunde.
Cum vând obiecte care pot fi cumpărate de mai multe ori?
Pentru astfel de obiecte sari peste verificarea "îl are deja" și dă nu un Tool, ci ceva ce se poate număra, de exemplu adaugă 1 la un IntValue care numără poțiunile. Căutarea prețului și verificarea monedelor lasă-le cum sunt.
De ce dispare magazinul când personajul face respawn?
ScreenGui-ul lui are ResetOnSpawn la true, valoarea implicită, așa că Roblox îl șterge la respawn. Setează-l la false, cum face scriptul de la pasul 3.
Pot lua un șablon gratuit de GUI de magazin?
Da, merge orice layout, dacă butoanele lui Buy trimit doar id-ul obiectului, iar cumpărarea însăși se face într-un Script de server precum ShopService. Înainte să iei un șablon, verifică dacă nu cumva monedele se scad sau obiectele se dau într-un LocalScript.
Surse și lecturi suplimentare
- Roblox Creator Docs: Securing the client-server boundary (în engleză). verificarea argumentelor remote-urilor, NaN, limitarea frecvenței și exemplul de magazin din joc
- Roblox Creator Docs: Remote events and callbacks (în engleză). RemoteFunction, InvokeServer, OnServerInvoke și riscurile InvokeClient
- Roblox Creator Docs: Passes (în engleză). crearea și vânzarea pass-urilor, UserOwnsGamePassAsync și PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (în engleză). Shop-ul din joc pe care Roblox îl creează automat
- Roblox Creator Docs: Developer Products (în engleză). cumpărături repetabile pe Robux și ProcessReceipt
- Roblox Creator Docs: StarterGear (în engleză). de ce un Tool din StarterGear revine după respawn
- Roblox Creator Docs: In-game tools (în engleză). Handle, ancorarea și RequiresHandle
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.