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
Jak zbudowany jest działający sklep
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.
| Część | Gdzie jest | Co robi |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | Id przedmiotów, nazwy, ceny i Tool, który daje każdy z nich. Czytają go obie strony. |
RemoteFunction BuyItem | ReplicatedStorage, w folderze ShopRemotes | Niesie żądanie zakupu na serwer i odpowiedź z powrotem. |
LocalScript ShopClient | StarterPlayerScripts | Buduje okno sklepu i wysyła id przedmiotu, gdy kliknięto przycisk Buy. |
Script ShopService | ServerScriptService | Sprawdza żądanie, pobiera Coins i wydaje Tool. |
| Toole, które sprzedajesz | ServerStorage, w folderze ShopItems | Oryginały, które kopiuje serwer. Nic z ServerStorage nie jest wysyłane graczom. |
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.
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.
- W Explorerze najedź kursorem na ReplicatedStorage, kliknij przycisk + i wstaw Folder o nazwie
ShopRemotes. Do środka wstaw RemoteFunction o nazwieBuyItem. - Najedź kursorem na ServerStorage i wstaw Folder o nazwie
ShopItems. - Włóż do ShopItems po jednym Tool na każdy przedmiot, o nazwach
ClassicSword,Flashlight,GrappleHookiSpeedCoil. Do pierwszego testu w Tool wystarczy jeden niezakotwiczony Part o nazwieHandle. 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. - 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:
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.
- W Explorerze rozwiń StarterPlayer, najedź kursorem na StarterPlayerScripts i wstaw LocalScript o nazwie
ShopClient. - Zastąp jego zawartość kodem poniżej.
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ą.
| Obiekt | Zadanie w sklepie | Główne właściwości |
|---|---|---|
ScreenGui | Przechowuje wszystko, co jest narysowane na ekranie | ResetOnSpawn false, żeby sklep przetrwał respawn |
Frame | Okno i każda karta przedmiotu | AnchorPoint 0.5, 0.5 i Position 0.5, 0.5, żeby okno było na środku |
UISizeConstraint | Ogranicza okno na dużych ekranach | MaxSize 640 na 460 |
ScrollingFrame | Przewija się, gdy kart jest więcej, niż się mieści | CanvasSize 0 i AutomaticCanvasSize Y, żeby obszar przewijania rósł razem z kartami |
UIGridLayout | Ustawia karty w rzędach i je zawija | CellSize 180 na 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | Zaokrągla rogi | CornerRadius od 8 do 14 pikseli |
UIPadding | Wewnętrzne odstępy | Od 10 do 12 pikseli z każdej strony |
TextButton | Przyciski Shop, zamykania i Buy | Event 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:
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.
| Oszust przysyła | Gdyby serwer mu uwierzył | Co robi ShopService |
|---|---|---|
| Cenę 0 | Wszystkie przedmioty za darmo | Ignoruje ją. Cena pochodzi z katalogu. |
| Cenę -1000 | Coins.Value -= -1000 daje mu 1 000 monet | Ignoruje ją. |
NaN zamiast ceny | Każde porównanie z NaN jest fałszywe, więc sprawdzenie "za mało monet" nigdy nie zadziała | Ignoruje ją. |
| Id, którego nie ma w katalogu, albo tabelę zamiast stringa | Błę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 razy | Obsługuje nie więcej niż jedno żądanie od gracza na pół sekundy. |
| Coins zmienione na swoim ekranie | Zakupy za monety, których nie ma | W 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
- 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.
- Spróbuj Speed Coil, który kosztuje 300. Linia statusu napisze, ilu monet jeszcze brakuje, i nic nie zostanie pobrane.
- Zresetuj postać przez menu w grze. Flashlight wróci do nowego Backpack dzięki kopii w StarterGear.
- Żeby dodać sobie monet podczas testu, kliknij przełącznik Client/Server i przejdź na Server, znajdź w Explorerze
Players, swoją nazwę,leaderstats,Coinsi 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 togiveTool. Okno sklepu odświeży się samo, bo nasłuchuje tych atrybutów. - Posiadania passa nie trzeba zapisywać:
UserOwnsGamePassAsyncpyta 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.
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.
- 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
- Roblox Creator Docs: Securing the client-server boundary (po angielsku). sprawdzanie argumentów remote’ów, NaN, ograniczanie częstotliwości i przykład sklepu w grze
- Roblox Creator Docs: Remote events and callbacks (po angielsku). RemoteFunction, InvokeServer, OnServerInvoke i ryzyka InvokeClient
- Roblox Creator Docs: Passes (po angielsku). tworzenie i sprzedaż passów, UserOwnsGamePassAsync i PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (po angielsku). Shop w grze, który Roblox tworzy automatycznie
- Roblox Creator Docs: Developer Products (po angielsku). powtarzalne zakupy za Robux i ProcessReceipt
- Roblox Creator Docs: StarterGear (po angielsku). dlaczego Tool w StarterGear wraca po respawnie
- Roblox Creator Docs: In-game tools (po angielsku). Handle, kotwiczenie i RequiresHandle
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ą.