Tutorial · Sisteme de joc

Cum faci un magazin în Roblox Studio

Un magazin într-un joc Roblox înseamnă două sarcini: un GUI care arată obiectele și un script de server care decide dacă are loc cumpărarea. În acest ghid le construim pe amândouă pentru un magazin pe monede care vinde instrumente și arătăm unde își au locul cumpărăturile pe Robux.

Actualizat 20 noiembrie 202613 min de cititAutor:

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ă
  1. Cum e construit
  2. 1. Pregătire
  3. 2. Catalogul de obiecte
  4. 3. GUI-ul magazinului
  5. 4. Cumpărături pe server
  6. De ce fără preț de la client
  7. 5. Test
  8. Gamepass
  9. Salvarea cumpărăturilor
  10. Common errors
  11. Cu RoCode
  12. Întrebări frecvente
  13. Surse și lecturi suplimentare

Cum e construit un magazin funcțional

IlustrațieJucătorul deschide magazinul și cumpără Flashlight pe 25 de monede: Coins scade de la 200 la 175, butonul devine Owned, iar instrumentul apare în hotbar.

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ă.

Cele cinci părți ale magazinului
ParteUnde se aflăCe face
ModuleScript ShopCatalogReplicatedStorageId-urile obiectelor, numele, prețurile și Tool-ul pe care îl dă fiecare. Îl citesc ambele părți.
RemoteFunction BuyItemReplicatedStorage, în folderul ShopRemotesDuce cererea de cumpărare la server și răspunsul înapoi.
LocalScript ShopClientStarterPlayerScriptsConstruiește fereastra magazinului și trimite id-ul obiectului când e apăsat un buton Buy.
Script ShopServiceServerScriptServiceVerifică cererea, scade Coins și dă Tool-ul.
Tool-urile pe care le vinziServerStorage, în folderul ShopItemsOriginalele pe care le copiază serverul. Nimic din ServerStorage nu se trimite jucătorilor.
Explorer-ul când magazinul e gata
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.

Script în ServerScriptService cu numele Leaderstats
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.

  1. În Explorer treci cu mouse-ul peste ReplicatedStorage, apasă butonul + și inserează un Folder numit ShopRemotes. În el inserează o RemoteFunction numită BuyItem.
  2. Treci cu mouse-ul peste ServerStorage și inserează un Folder numit ShopItems.
  3. Pune în ShopItems câte un Tool pentru fiecare obiect, cu numele ClassicSword, Flashlight, GrappleHook și SpeedCoil. Pentru primul test, un Tool are nevoie doar de un Part neancorat numit Handle. 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.
  4. 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:

ModuleScript în ReplicatedStorage cu numele ShopCatalog
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.

  1. În Explorer deschide StarterPlayer, treci cu mouse-ul peste StarterPlayerScripts și inserează un LocalScript numit ShopClient.
  2. Înlocuiește-i conținutul cu codul de mai jos.
LocalScript în StarterPlayerScripts cu numele ShopClient
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.

Obiectele GUI și proprietățile importante
ObiectSarcina în magazinProprietățile principale
ScreenGuiȚine tot ce e desenat pe ecranResetOnSpawn false, ca magazinul să supraviețuiască unui respawn
FrameFereastra și fiecare card de obiectAnchorPoint 0.5, 0.5 și Position 0.5, 0.5, ca fereastra să fie în centru
UISizeConstraintLimitează fereastra pe ecranele mariMaxSize 640 pe 460
ScrollingFrameSe derulează când sunt mai multe carduri decât încapCanvasSize 0 și AutomaticCanvasSize Y, ca zona derulabilă să crească odată cu cardurile
UIGridLayoutPune cardurile pe rânduri și le mută pe rândul următorCellSize 180 pe 200, CellPadding 12, SortOrder LayoutOrder
UICornerRotunjește colțurileCornerRadius de la 8 la 14 pixeli
UIPaddingMargini interioareDe la 10 la 12 pixeli pe fiecare latură
TextButtonButoanele Shop, de închidere și BuyEvenimentul 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:

Script în ServerScriptService cu numele ShopService
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.

Ce se întâmplă dacă serverul are încredere în client
Trișorul trimiteDacă serverul l-ar credeCe face ShopService
Prețul 0Toate obiectele sunt gratuiteÎl ignoră. Prețul vine din catalog.
Prețul -1000Coins.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 șirErori în script sau obiecte pe care nu voiai să le vinziRă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 oriTratează cel mult o cerere de la un jucător la fiecare jumătate de secundă.
Coins schimbat pe propriul ecranCumpărături cu monede pe care nu le areNu 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

  1. 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.
  2. Încearcă Speed Coil, care costă 300. Rândul de stare scrie câte monede îți mai lipsesc și nu se ia nimic.
  3. Resetează-ți personajul din meniul din joc. Flashlight revine în noul Backpack datorită copiei din StarterGear.
  4. 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 face giveTool. 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.

Tu scrii

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.

RoCode face
  • 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

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.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.