Poradnik · Systemy gry

Jak zrobić sklep w Roblox Studio

Sklep w grze Roblox to dwa zadania: GUI, które pokazuje przedmioty, i skrypt serwerowy, który decyduje, czy zakup dojdzie do skutku. W tym poradniku budujemy jedno i drugie dla sklepu za monety, który sprzedaje narzędzia, i pokazujemy, gdzie jest miejsce na zakupy za Robux.

Zaktualizowano 20 listopada 202612 min czytaniaAutor:

W skrócie

Trzymaj przedmioty i ceny w ModuleScript w ReplicatedStorage, zbuduj okno z ScreenGui, ScrollingFrame i UIGridLayout i niech każdy przycisk Buy wywołuje RemoteFunction, przekazując tylko id przedmiotu. Dalej Script w ServerScriptService sam znajduje cenę, sprawdza i pobiera Coins gracza i wydaje przedmiot.

  • Nigdy nie pozwalaj klientowi przysyłać ceny. Każdy może wywołać twoje remote’y z dowolnymi wartościami, więc serwer bierze cenę ze swojej kopii katalogu.
  • Kupiony Tool wydawaj przez sklonowanie z ServerStorage do Backpack gracza (żeby mógł używać od razu) i do StarterGear (żeby wrócił po respawnie).
  • To, co sprzedaje się za Robux, to passy i developer products, a obsługuje je MarketplaceService. Dla nich Roblox sam tworzy też Shop i to nie to samo co sklep za monety.
Na tej stronie
  1. Jak to działa
  2. 1. Przygotowanie
  3. 2. Katalog przedmiotów
  4. 3. GUI sklepu
  5. 4. Zakupy na serwerze
  6. Dlaczego bez ceny od klienta
  7. 5. Test
  8. Game pass
  9. Zapis zakupów
  10. Common errors
  11. Z RoCode
  12. Najczęstsze pytania
  13. Źródła i dalsza lektura

Jak zbudowany jest działający sklep

IlustracjaGracz otwiera sklep i kupuje Flashlight za 25 monet: Coins spadają z 200 do 175, przycisk zmienia się na Owned, a narzędzie pojawia się na hotbarze.

Sklep, który działa w prawdziwej grze, jest podzielony między urządzenie gracza a serwer. Urządzenie rysuje okno i mówi "chcę kupić miecz". Serwer, jedyna strona, której można ufać, decyduje, czy to się stanie. Skrypty sklepu, które "nie działają" albo które gracze psują cheatami, często podejmują tę decyzję po złej stronie.

Pięć części sklepu
CzęśćGdzie jestCo robi
ModuleScript ShopCatalogReplicatedStorageId przedmiotów, nazwy, ceny i Tool, który daje każdy z nich. Czytają go obie strony.
RemoteFunction BuyItemReplicatedStorage, w folderze ShopRemotesNiesie żądanie zakupu na serwer i odpowiedź z powrotem.
LocalScript ShopClientStarterPlayerScriptsBuduje okno sklepu i wysyła id przedmiotu, gdy kliknięto przycisk Buy.
Script ShopServiceServerScriptServiceSprawdza żądanie, pobiera Coins i wydaje Tool.
Toole, które sprzedajeszServerStorage, w folderze ShopItemsOryginały, które kopiuje serwer. Nic z ServerStorage nie jest wysyłane graczom.
Explorer, gdy sklep jest gotowy
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: monety i przedmioty na sprzedaż

Sklep wydaje wartość Coins w leaderstats gracza. Jeśli przeszedłeś poradnik o leaderboardzie, już ją masz i ten skrypt możesz pominąć. W przeciwnym razie wstaw Script do ServerScriptService o nazwie Leaderstats. Daje każdemu 200 monet na start, żeby zakupy można było testować od razu.

Script w ServerScriptService o nazwie Leaderstats
local Players = game:GetService("Players")

local STARTING_COINS = 200 -- wystarczy do testu sklepu; ustaw 0, gdy gracze będą mogli zarabiać monety

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

Trzymaj tylko jeden skrypt leaderstats. Dwa skrypty, z których każdy tworzy folder leaderstats, dają każdemu graczowi dwa foldery, a sklep może przeczytać nie ten.

Dalej utwórz obiekty, których szukają skrypty. Wielkość liter w nazwach ma znaczenie, więc pisz je dokładnie tak jak tutaj.

  1. W Explorerze najedź kursorem na ReplicatedStorage, kliknij przycisk + i wstaw Folder o nazwie ShopRemotes. Do środka wstaw RemoteFunction o nazwie BuyItem.
  2. Najedź kursorem na ServerStorage i wstaw Folder o nazwie ShopItems.
  3. Włóż do ShopItems po jednym Tool na każdy przedmiot, o nazwach ClassicSword, Flashlight, GrappleHook i SpeedCoil. Do pierwszego testu w Tool wystarczy jeden niezakotwiczony Part o nazwie Handle. Pasuje też każdy Tool, który już masz: daj mu odpowiednią nazwę. Broń, która naprawdę zadaje obrażenia, zbuduj według poradnika o mieczu albo poradnika o broni palnej; w każdym jest opisane, jak połączyć ją z katalogiem.
  4. Zaznacz każdy Tool i odznacz CanBeDropped w oknie Properties. Gdy jest zaznaczone, naciśnięcie Backspace wyrzuca narzędzie do Workspace i każdy gracz może podnieść to, za co zapłacił kupujący.

Możesz zacząć od jednego Toola. Jeśli brakuje Toola danego przedmiotu, serwer odmawia sprzedaży tego przedmiotu i wypisuje ostrzeżenie z jego nazwą, więc graczowi nic nie jest pobierane.

Krok 2: przedmioty i ceny w katalogu

Katalog to jedyna lista wszystkiego, co sprzedaje sklep. LocalScript czyta go, żeby narysować karty, a serwer czyta go, żeby znaleźć ceny, więc zmiana ceny to jedna poprawka w jednym miejscu.

Najedź kursorem na ReplicatedStorage, wstaw ModuleScript, zmień jego nazwę na ShopCatalog i zastąp zawartość tym:

ModuleScript w ReplicatedStorage o nazwie ShopCatalog
export type ShopItem = {
	id: string, -- potem zapisywany w magazynie danych: nie zmieniaj go, gdy gracze już mają przedmiot
	name: string, -- pokazywane na karcie; można zmieniać
	price: number, -- w Coins
	description: string,
	toolName: string, -- Tool w ServerStorage.ShopItems, który dostaje gracz
}

-- Karty pojawiają się w tej kolejności
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

-- Zwraca przedmiot o tym id albo nil, jeśli takiego przedmiotu nie ma
function ShopCatalog.get(id: string): ShopItem?
	return byId[id]
end

-- Atrybut Player, który serwer ustawia na true, gdy gracz ma przedmiot
function ShopCatalog.ownedAttribute(id: string): string
	return "Owns_" .. id
end

return ShopCatalog

Każdy przedmiot ma id i osobno wyświetlaną nazwę name. Serwer zapisuje właśnie id, gdy gracz coś ma, więc "Classic Sword" można potem przemianować bez psucia zapisanych zakupów. Opisy to tylko tekst na karcie; co robi Tool, decydują jego własne skrypty.

Gracze mogą przeczytać ModuleScript w ReplicatedStorage, więc te ceny są publiczne. To normalne: i tak są napisane na kartach. Ważne jest to, że klient i serwer uruchamiają każdy swoją kopię modułu, więc gracz, który zmienił ceny na swoim urządzeniu, niczego nie zmienia na serwerze.

Krok 3: budujemy GUI sklepu

Ten LocalScript buduje całe okno w kodzie: przycisk Shop, panel z przewijaną siatką kart, przycisk Buy dla każdego przedmiotu z katalogu, licznik Coins i linię statusu na odpowiedzi serwera. Skoro wszystko jest zrobione kodem, możesz go wkleić i kliknąć Play. Tabela pod nim wymienia każdy obiekt, jeśli chcesz ułożyć okno ręcznie.

  1. W Explorerze rozwiń StarterPlayer, najedź kursorem na StarterPlayerScripts i wstaw LocalScript o nazwie ShopClient.
  2. Zastąp jego zawartość kodem poniżej.
LocalScript w StarterPlayerScripts o nazwie ShopClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Co zwraca moduł ShopCatalog, żeby ścisłe sprawdzanie typów sprawdzało pola, których używamy
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: przechowuje wszystko, co sklep rysuje na ekranie gracza
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- sklep zostaje, gdy postać się respawnuje

-- Przycisk przy lewej krawędzi, który otwiera i zamyka sklep
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 sklepu: na środku, ukryte, dopóki gracz go nie otworzy
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) -- nie pozwala oknu zrobić się ogromnym na dużych ekranach
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

-- Tu pokazują się odpowiedzi serwera, na przykład "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: obszar, który się przewija, gdy kart jest więcej, niż się mieści
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() -- zaczyna od zera; AutomaticCanvasSize rozciąga go pod karty
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel

-- UIGridLayout: układa karty w rzędach i przenosi je do następnego rzędu
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..."

		-- Wysyłamy tylko id przedmiotu. Cenę serwer znajduje sam.
		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)

	-- Serwer ustawia ten atrybut, gdy zakup się udał (albo gdy wczytały się zapisane przedmioty)
	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")

-- Pokazujemy monety gracza. Prawdziwa wartość jest na serwerze; tu jest tylko wyświetlana.
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()

Przyciski używają Activated, a nie MouseButton1Click: odpala się na kliknięcie myszą, na dotknięcie na telefonie i na przycisk A albo krzyżyk na padzie.

Definicje type na górze opisują, co zwraca ShopCatalog, żeby ścisłe sprawdzanie typów wyłapało literówkę w polu, na przykład item.prise. Gdy gra działa, niczego nie zmieniają.

Obiekty GUI i ważne właściwości
ObiektZadanie w sklepieGłówne właściwości
ScreenGuiPrzechowuje wszystko, co jest narysowane na ekranieResetOnSpawn false, żeby sklep przetrwał respawn
FrameOkno i każda karta przedmiotuAnchorPoint 0.5, 0.5 i Position 0.5, 0.5, żeby okno było na środku
UISizeConstraintOgranicza okno na dużych ekranachMaxSize 640 na 460
ScrollingFramePrzewija się, gdy kart jest więcej, niż się mieściCanvasSize 0 i AutomaticCanvasSize Y, żeby obszar przewijania rósł razem z kartami
UIGridLayoutUstawia karty w rzędach i je zawijaCellSize 180 na 200, CellPadding 12, SortOrder LayoutOrder
UICornerZaokrągla rogiCornerRadius od 8 do 14 pikseli
UIPaddingWewnętrzne odstępyOd 10 do 12 pikseli z każdej strony
TextButtonPrzyciski Shop, zamykania i BuyEvent Activated

Jeśli chcesz narysować okno ręcznie, zbuduj te same obiekty w StarterGui z tymi właściwościami, tam też ustaw ResetOnSpawn w ScreenGui na false i zostaw jedną kartę jako szablon, który LocalScript klonuje dla każdego przedmiotu z katalogu. Wtedy skrypt tylko wypełnia karty i podłącza przyciski. Logika zakupu w następnym kroku się nie zmienia.

Jeśli twoja gra zaczyna się od menu głównego, w tamtym poradniku jest jedna linia do dodania w ShopClient, żeby przycisk Shop pojawiał się dopiero po tym, jak gracz kliknie Play. Żeby sklep otwierał się rozmową ze sprzedawcą, poradnik o dialogach z NPC pokazuje, jak dodać akcję OpenShop, która każe ShopClient otworzyć okno, a zakupy dalej przechodzą przez serwerowe sprawdzenia sklepu.

Krok 4: sprawdzenie i zakup na serwerze

Ten Script to jedyne miejsce, gdzie może dojść do zakupu. Dostaje id przedmiotu, sprawdza je, znajduje cenę, sprawdza Coins gracza, potem pobiera monety i wydaje Tool. Przyciskowi Buy odpowiada true albo false i komunikatem do pokazania.

Najedź kursorem na ServerScriptService, wstaw Script o nazwie ShopService i wklej do niego to:

Script w ServerScriptService o nazwie ShopService
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Co zwraca moduł ShopCatalog, żeby ścisłe sprawdzanie typów sprawdzało pola, których używamy
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: gracz może używać narzędzia od razu
	local backpack = player:FindFirstChildOfClass("Backpack")
	if backpack then
		template:Clone().Parent = backpack
	end
	-- StarterGear: Roblox kopiuje go ponownie do Backpack przy każdym pojawieniu się postaci
	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 przysyła tylko id przedmiotu, więc to musi być string
	if type(itemId) ~= "string" then
		return false, "That item does not exist."
	end

	-- 2. Ignorujemy podwójne kliknięcia i strumienie żądań ze skryptów
	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. Szukamy przedmiotu we własnej kopii katalogu na serwerze
	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 pochodzi z katalogu, nigdy od klienta
	if coins.Value < item.price then
		return false, `You need {item.price - coins.Value} more coins.`
	end

	-- 5. Pobieramy monety, potem wydajemy przedmiot. Nic tu nie oddaje wykonania, więc dwa żądania
	-- od jednego gracza nie mogą oba przejść sprawdzeń wyżej, zanim to się wykona.
	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)

Posiadanie jest przechowywane jako atrybut Player, na przykład Owns_sword. Atrybuty ustawiane przez serwer replikują się na urządzenie gracza, więc LocalScript może przełączyć kartę na "Owned". Zmiana, którą gracz robi w swojej kopii, nie dociera do serwera.

Tool trafia w dwa miejsca. Kopia w Backpack od razu pojawia się na hotbarze. Kopię w StarterGear Roblox wkłada do nowego Backpack za każdym razem, gdy pojawia się postać. Bez niej kupiony przedmiot zniknie przy pierwszej śmierci gracza.

Dlaczego klient nigdy nie przysyła ceny

Wszystko, co jest na urządzeniu gracza, ten gracz może zmienić. Oszuści uruchamiają własny kod w swojej kopii gry: mogą czytać twoje LocalScripty, zmieniać GUI i wywoływać BuyItem:InvokeServer() z dowolnymi argumentami dowolnie wiele razy. Poradnik Roblox o bezpieczeństwie każe sprawdzać i typ, i wartość wszystkiego, co dostaje remote, a jako przykład podaje właśnie sklep.

Co się stanie, jeśli serwer ufa klientowi
Oszust przysyłaGdyby serwer mu uwierzyłCo robi ShopService
Cenę 0Wszystkie przedmioty za darmoIgnoruje ją. Cena pochodzi z katalogu.
Cenę -1000Coins.Value -= -1000 daje mu 1 000 monetIgnoruje ją.
NaN zamiast cenyKażde porównanie z NaN jest fałszywe, więc sprawdzenie "za mało monet" nigdy nie zadziałaIgnoruje ją.
Id, którego nie ma w katalogu, albo tabelę zamiast stringaBłędy w skrypcie albo przedmioty, których nie zamierzałeś sprzedawaćOdpowiada "That item does not exist."
Setki żądań na sekundęObciążenie serwera, a każda dziura w sprawdzeniach zadziała setki razyObsługuje nie więcej niż jedno żądanie od gracza na pół sekundy.
Coins zmienione na swoim ekranieZakupy za monety, których nie maW ogóle tego nie widzi. Serwer czyta tylko swoją wartość Coins.

Ta zasada pasuje do każdego remote’a, który piszesz: wysyłaj to, co wybrał gracz, na przykład id przedmiotu albo numer slotu, i nigdy to, ile to kosztuje albo co ma dostać. Poradnik o RemoteEvent szerzej omawia sprawdzanie argumentów remote’a.

Krok 5: testujemy sklep

  1. Kliknij Play. Po lewej pojawi się przycisk Shop. Otwórz go i kup Flashlight: Coins zmniejszą się o 25, narzędzie pojawi się na hotbarze, a jego przycisk zmieni się na Owned.
  2. Spróbuj Speed Coil, który kosztuje 300. Linia statusu napisze, ilu monet jeszcze brakuje, i nic nie zostanie pobrane.
  3. Zresetuj postać przez menu w grze. Flashlight wróci do nowego Backpack dzięki kopii w StarterGear.
  4. Żeby dodać sobie monet podczas testu, kliknij przełącznik Client/Server i przejdź na Server, znajdź w Explorerze Players, swoją nazwę, leaderstats, Coins i zmień jego Value w oknie Properties. To samo w trybie Client zmienia tylko twój ekran i to jest właśnie taka zmiana, którą serwer ignoruje.

Jeśli przycisk odpowiada "The shop did not answer", otwórz okno Output przez menu Window w Studio i znajdź czerwony błąd od ShopService. Jeśli natomiast przycisk wisi na "Buying...", ShopService nie jest uruchomiony albo utknął, czekając na obiekt: zobacz częste błędy.

Sprzedaż game passa za Robux

Monety to twoja własna waluta, więc sklep wyżej sam rozstrzyga każdy zakup. To, co gracz kupuje za Robux, działa inaczej: game pass kupuje się raz i zostaje na zawsze (bonusy VIP, stałe narzędzie), a developer product można kupować raz za razem (paczka monet, pominięcie poziomu). Oba idą przez MarketplaceService od Roblox, a płatność przyjmuje Roblox, a nie twój skrypt.

Z tego poradnika przenoszą się dwie zasady: okno zakupu uruchamiaj przyciskiem na kliencie, a bonus wydawaj tylko na serwerze, gdy Roblox potwierdził zakup albo gracz już ma passa. Poradnik o skrypcie game passa buduje to w całości: sprawdzenie posiadania przy wejściu, okno zakupu, bonusy w rodzaju drzwi VIP i kiedy zamiast passa lepiej wziąć developer product. Żeby wybrać cenę, darmowy kalkulator prowizji Robux pokazuje, ile pass albo developer product przynosi ci po udziale Roblox.

Zapisujemy zakupy graczy

Wszystko, co zrobiliśmy, żyje jedną sesję: monety i kupione przedmioty resetują się, gdy gracz wychodzi, dopóki nie zapiszesz ich przez magazyn danych. Żeby nie powtarzać tu kodu zapisu, przejdź poradnik o DataStore (albo krok 3 poradnika o leaderboardzie, tam wersja jest krótsza) i pamiętaj o zasadach sklepu:

  • Zapisuj id przedmiotów, na przykład { "sword", "flashlight" }, w tej samej tabeli co wartość Coins, żeby jeden zapis zapisywał i wydane monety, i kupiony przedmiot. Tooli ani innych instancji nie da się włożyć do magazynu danych.
  • Gdy dane się wczytały, przejdź po zapisanych id, pomiń te, których nie ma już w katalogu, ustaw każdy atrybut Owns_ i wydaj Tool tak samo, jak robi to giveTool. Okno sklepu odświeży się samo, bo nasłuchuje tych atrybutów.
  • Posiadania passa nie trzeba zapisywać: UserOwnsGamePassAsync pyta Roblox za każdym razem, gdy gracz wchodzi.
  • Nigdy nie zapisuj gracza, którego dane się nie wczytały, inaczej nieudane wczytanie może zastąpić jego zakupy pustą listą.

Częste błędy i rozwiązania

Gdy sklep zachowuje się dziwnie, najpierw sprawdź to. Na początek otwórz okno Output (menu Window, potem Output): błąd skryptu podaje nazwę skryptu i linię.

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

Skrypt czeka na obiekt, którego nie ma pod tą dokładną nazwą. Sprawdź pisownię i wielkie litery w ShopRemotes, BuyItem, ShopCatalog i ShopItems oraz czy ShopItems leży w ServerStorage, a nie w ReplicatedStorage. Poradnik o błędach skryptów szczegółowo omawia to ostrzeżenie.

Przycisk Buy wisi na "Buying..." i nie odpowiada

Na serwerze nikt nie ustawił BuyItem.OnServerInvoke, więc Roblox trzyma żądanie, dopóki to się nie stanie. Upewnij się, że ShopService to Script, a nie LocalScript, i leży w ServerScriptService, i poszukaj w Output ostrzeżenia Infinite yield possible od ShopService: oznacza, że skrypt utknął, czekając na ShopCatalog, ShopRemotes albo ShopItems.

Przycisk Buy pisze "The shop did not answer"

Wywołanie serwera wywaliło się, zamiast zwrócić odpowiedź. Zwykła przyczyna to błąd wewnątrz ShopService podczas obsługi żądania, więc znajdź w Output czerwony błąd od ShopService: jest w nim podana linia.

Przycisk pisze "This item is not available right now"

Serwer nie znalazł Toola z toolName tego przedmiotu wewnątrz ServerStorage, ShopItems. W Output jest ostrzeżenie z dokładną nazwą, której szukał.

Kupiłem narzędzie, ale postać nie może go trzymać albo utyka

Tool musi mieć dokładnie jeden part o nazwie Handle bezpośrednio w środku i żaden z jego partów nie może być zakotwiczony. Dla narzędzia, którego nie trzeba trzymać w ręce, odznacz zamiast tego RequiresHandle.

Monety zmniejszyły się na moim ekranie, ale nie u innych

Zakup odbył się w LocalScript, więc zmieniło się tylko twoje urządzenie. Przenieś pobieranie monet i wydawanie Toola do serwerowego Script, jak w kroku 4.

Kupione przedmioty znikają po ponownym wejściu

Na razie nic się nie zapisuje. Zobacz zapis zakupów.

Zrób to z RoCode

Jeśli nie chce ci się składać tego wszystkiego ręcznie, RoCode może to zrobić w grze, którą masz otwartą. To niezależny agent AI do kodu: opisujesz funkcję na jego czacie w przeglądarce, a jego plugin do Roblox Studio tworzy skrypty, remote i GUI w twoim Explorerze, więc nie musisz kopiować kodu z okna czatu.

Ty piszesz

Dodaj sklep za monety: przycisk Shop, który otwiera siatkę czterech narzędzi z cenami w Coins z moich leaderstats. Serwer ma sprawdzać cenę i wydawać narzędzie do Backpack i StarterGear.

RoCode robi
  • Może przejrzeć twoją grę przez Search Scripts i Read Script w poszukiwaniu istniejących leaderstats i kodu sklepu, żeby użyć twojej wartości Coins, a nie dodawać drugiej
  • Może zbudować szkielet okna przez Build UI: układ sklepu ma karty-zaślepki i LocalScript do efektów przy najechaniu i przycisku Close; logika zakupu jest pisana osobnymi skryptami
  • Tworzy RemoteFunction przez Create Instance i pisze ModuleScript katalogu, serwerowy Script i LocalScript przez Create Script
  • Sprawdza kompilację każdego skryptu w Studio przez Check Script (typów nie sprawdza i skryptów nie uruchamia), a każda paczka zmian to punkt cofania w Studio

Passy i tak musisz utworzyć w Creator Hub sam, bo RoCode nie umie tworzyć passów ani developer products, a zakupy też testujesz ty: z pluginem 3.9 lub nowszym RoCode może uruchomić krótki playtest i przeczytać błędy, a z pluginem 3.9.15 lub nowszym jego testowa postać może klikać przyciski Shop i Buy, ale sprawdza tylko to, co sam postanowił przetestować. Sklep zwykle przychodzi po głównej rozgrywce i zapisie; krokowy cykl tworzenia gry z RoCode pokazuje, gdzie jest jego miejsce. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Co jest lepsze dla przycisku Buy w Roblox: RemoteEvent czy RemoteFunction?

Pasuje jedno i drugie, jeśli sprawdza serwer. RemoteFunction pozwala przyciskowi poczekać na odpowiedź serwera i ją pokazać, dlatego poradnik go używa, a w poradniku Roblox o bezpieczeństwie przykład sklepu też jest na RemoteFunction. Wywołuj go tylko z klienta: serwer, który wywołuje InvokeClient, może czekać w nieskończoność, jeśli klient nigdy nie odpowie. Poradnik o RemoteEvent porównuje obie opcje.

Jak otworzyć sklep przez NPC, a nie przyciskiem?

Włóż ProximityPrompt do jakiegoś partu NPC, na przykład do jego HumanoidRootPart, nasłuchuj jego eventu Triggered w serwerowym Script i wysyłaj temu graczowi RemoteEvent, żeby LocalScript pokazał panel. Jeśli kupować można tylko przy NPC, sprawdzaj też odległość od NPC w handlerze BuyItem, bo klient może wywołać remote skądkolwiek.

Jak sprzedawać przedmioty, które można kupić kilka razy?

Dla takich przedmiotów pomiń sprawdzenie "już masz" i wydawaj nie Tool, tylko coś, co da się policzyć, na przykład dodawaj 1 do IntValue, który liczy mikstury. Szukanie ceny i sprawdzanie monet zostaw bez zmian.

Dlaczego sklep znika, gdy postać się respawnuje?

Jego ScreenGui ma ResetOnSpawn ustawione na true, to wartość domyślna, więc Roblox usuwa go przy respawnie. Ustaw false, tak jak robi skrypt w kroku 3.

Czy mogę wziąć darmowy szablon GUI sklepu?

Tak, pasuje każdy układ, jeśli jego przyciski Buy wysyłają tylko id przedmiotu, a sam zakup odbywa się w serwerowym Script w rodzaju ShopService. Zanim weźmiesz szablon, sprawdź, czy nie pobiera monet albo nie wydaje przedmiotów w LocalScript.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.