Kurz gesagt
Leg deine Items und Preise in ein ModuleScript in ReplicatedStorage, bau das Fenster aus einem ScreenGui, einem ScrollingFrame und einem UIGridLayout, und lass jeden Buy-Button eine RemoteFunction nur mit der id des Items aufrufen. Ein Script in ServerScriptService sucht dann selbst den Preis heraus, prüft die Coins des Spielers, zieht sie ab und gibt das Item.
- Lass den Client nie den Preis schicken. Jeder kann deine Remotes mit beliebigen Werten aufrufen, also liest der Server den Preis aus seiner eigenen Kopie des Katalogs.
- Gib ein gekauftes Tool, indem du es aus ServerStorage in den Backpack des Spielers klonst (zum sofortigen Benutzen) und in sein StarterGear (damit es nach einem Respawn zurückkommt).
- Was für Robux verkauft wird, sind Passes und Developer Products, die über MarketplaceService laufen. Roblox erstellt dafür auch automatisch einen Shop, der von einem Coin-Shop getrennt ist.
Auf dieser Seite
Wie ein funktionierender Shop aufgebaut ist
Ein Shop, der in einem Live-Spiel funktioniert, ist zwischen dem Gerät des Spielers und dem Server aufgeteilt. Das Gerät zeichnet das Fenster und sagt "Ich will das Schwert kaufen". Der Server, die einzige Seite, der du trauen kannst, entscheidet, ob das passiert. Shop-Skripte, die "nicht funktionieren" oder die Spieler ausnutzen, treffen diese Entscheidung oft auf der falschen Seite.
| Baustein | Wo er liegt | Was er macht |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | Item-ids, Namen, Preise und das Tool, das jedes Item gibt. Beide Seiten lesen es. |
RemoteFunction BuyItem | ReplicatedStorage, in einem Ordner namens ShopRemotes | Bringt die Kaufanfrage zum Server und die Antwort zurück. |
LocalScript ShopClient | StarterPlayerScripts | Baut das Shop-Fenster und schickt die Item-id, wenn ein Buy-Button gedrückt wird. |
Script ShopService | ServerScriptService | Prüft die Anfrage, zieht die Coins ab und gibt das Tool. |
| Die Tools, die du verkaufst | ServerStorage, in einem Ordner namens ShopItems | Die Originale, die der Server kopiert. Nichts in ServerStorage wird an Spieler geschickt. |
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
Schritt 1: Coins und die Items zum Verkaufen einrichten
Der Shop gibt einen Coins-Wert in den leaderstats des Spielers aus. Wenn du dem Leaderboard-Guide gefolgt bist, hast du schon einen, also überspring dieses Skript. Sonst füge in ServerScriptService ein Script namens Leaderstats ein. Es gibt allen zum Start 200 Coins, damit du Käufe sofort testen kannst.
local Players = game:GetService("Players")
local STARTING_COINS = 200 -- genug, um den Shop zu testen; setz es auf 0, sobald Spieler Coins verdienen können
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
Behalte nur ein leaderstats-Skript. Zwei Skripte, die jeweils einen leaderstats-Ordner erstellen, geben jedem Spieler zwei Ordner, und der Shop liest vielleicht den falschen.
Erstell als Nächstes die Objekte, nach denen die Skripte suchen. Bei Namen zählt die Groß- und Kleinschreibung, also tipp sie genau so wie gezeigt.
- Fahr im Explorer mit der Maus über ReplicatedStorage, klick auf den Button + und füge einen Folder namens
ShopRemotesein. Füge darin eine RemoteFunction namensBuyItemein. - Fahr mit der Maus über ServerStorage und füge einen Folder namens
ShopItemsein. - Leg für jedes Item ein Tool in ShopItems, mit den Namen
ClassicSword,Flashlight,GrappleHookundSpeedCoil. Für einen ersten Test braucht ein Tool nur einen nicht verankerten Part namensHandledarin. Jedes Tool, das du schon hast, geht auch: Gib ihm den passenden Namen. Für eine Waffe, die wirklich Schaden macht, bau eine mit dem Schwert-Guide oder dem Waffen-Guide (auf Englisch); beide sagen, wie du sie an den Katalog anpasst. - Wähl jedes Tool aus und entferne im Properties-Fenster den Haken bei CanBeDropped. Solange er gesetzt ist, lässt die Rücktaste das Tool in den Workspace fallen, wo jeder Spieler aufheben kann, was der Käufer bezahlt hat.
Du kannst mit nur einem Tool anfangen. Fehlt das Tool eines Items, verweigert der Server den Verkauf dieses Items und gibt eine Warnung mit seinem Namen aus, also wird dem Spieler nichts abgezogen.
Schritt 2: Items und Preise in einen Katalog schreiben
Der Katalog ist die eine Liste mit allem, was der Shop verkauft. Das LocalScript liest ihn, um die Karten zu zeichnen, und der Server liest ihn, um Preise nachzuschlagen, also ist eine Preisänderung eine Änderung an einer Stelle.
Fahr mit der Maus über ReplicatedStorage, füge ein ModuleScript ein, benenn es in ShopCatalog um und ersetz seinen Inhalt durch das hier:
export type ShopItem = {
id: string, -- wird später in Data Stores gespeichert: nie ändern, sobald Spieler das Item besitzen
name: string, -- steht auf der Karte; darf geändert werden
price: number, -- Preis in Coins
description: string,
toolName: string, -- das Tool in ServerStorage.ShopItems, das der Spieler bekommt
}
-- Die Karten erscheinen in dieser Reihenfolge
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
-- Gibt das Item mit dieser id zurück, oder nil, wenn es kein solches Item gibt
function ShopCatalog.get(id: string): ShopItem?
return byId[id]
end
-- Das Player-Attribut, das der Server auf true setzt, wenn der Spieler ein Item besitzt
function ShopCatalog.ownedAttribute(id: string): string
return "Owns_" .. id
end
return ShopCatalog
Jedes Item hat neben dem angezeigten name eine id. Die id speichert der Server, wenn ein Spieler etwas besitzt, also kannst du "Classic Sword" später umbenennen, ohne gespeicherte Käufe kaputtzumachen. Die Beschreibungen sind nur Text auf der Karte; was ein Tool macht, bestimmen die eigenen Skripte des Tools.
Spieler können ein ModuleScript in ReplicatedStorage lesen, also sind diese Preise öffentlich. Das ist in Ordnung: Sie stehen sowieso auf den Karten. Wichtig ist, dass Client und Server jeweils ihre eigene Kopie des Moduls ausführen, also ändert ein Spieler, der die Preise auf seinem Gerät bearbeitet, nichts auf dem Server.
Schritt 3: Das Shop-GUI bauen
Dieses LocalScript baut das ganze Fenster per Code: einen Shop-Button, ein Panel mit einem scrollbaren Raster aus Karten, einen Buy-Button pro Katalog-Item, eine Coins-Anzeige und eine Statuszeile für die Antworten des Servers. Weil alles Code ist, kannst du es einfügen und auf Play drücken. Die Tabelle danach listet jedes Objekt, falls du das Fenster lieber von Hand aufbaust.
- Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts und füge ein LocalScript namens
ShopClientein. - Ersetz seinen Inhalt durch den Code unten.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Was das Modul ShopCatalog zurückgibt, damit die strikte Typprüfung die Felder prüfen kann, die wir nutzen
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: enthält alles, was der Shop auf den Bildschirm des Spielers zeichnet
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- den Shop behalten, wenn der Charakter respawnt
-- Ein Button am linken Rand, der den Shop öffnet und schließt
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)
-- Das Shop-Fenster: zentriert und versteckt, bis der Spieler es öffnet
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) -- verhindert, dass das Fenster auf großen Bildschirmen riesig wird
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
-- Antworten vom Server, etwa "You need 20 more coins.", erscheinen hier
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: der Bereich, der scrollt, wenn mehr Karten da sind, als hineinpassen
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() -- startet bei null; AutomaticCanvasSize vergrößert ihn passend zu den Karten
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel
-- UIGridLayout: ordnet die Karten in Reihen an und bricht in die nächste Reihe um
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..."
-- Nur die id des Items schicken. Der Server sucht den Preis selbst heraus.
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)
-- Der Server setzt dieses Attribut, wenn der Kauf durchgeht (oder wenn gespeicherte Items laden)
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")
-- Die Coins des Spielers anzeigen. Den echten Wert hat der Server; das hier zeigt ihn nur an.
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()
Die Buttons nutzen Activated statt MouseButton1Click: Es feuert bei einem Mausklick, einem Tippen auf dem Handy und der A- oder Kreuz-Taste am Controller.
Die type-Definitionen oben beschreiben, was ShopCatalog zurückgibt, damit die strikte Typprüfung ein falsch geschriebenes Feld wie item.prise findet. Wenn das Spiel läuft, ändern sie nichts.
| Objekt | Aufgabe im Shop | Wichtige Eigenschaften |
|---|---|---|
ScreenGui | Enthält alles, was auf dem Bildschirm gezeichnet wird | ResetOnSpawn false, damit der Shop einen Respawn übersteht |
Frame | Das Fenster und jede Item-Karte | AnchorPoint 0.5, 0.5 und Position 0.5, 0.5, um das Fenster zu zentrieren |
UISizeConstraint | Begrenzt das Fenster auf großen Bildschirmen | MaxSize 640 mal 460 |
ScrollingFrame | Scrollt, wenn mehr Karten da sind, als hineinpassen | CanvasSize 0 und AutomaticCanvasSize Y, damit der Scrollbereich mit den Karten wächst |
UIGridLayout | Ordnet die Karten in Reihen an und bricht sie um | CellSize 180 mal 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | Rundet Ecken ab | CornerRadius 8 bis 14 Pixel |
UIPadding | Innenabstand | 10 bis 12 Pixel auf jeder Seite |
TextButton | Shop-, Schließen- und Buy-Buttons | Das Event Activated |
Um das Fenster stattdessen von Hand zu gestalten, bau dieselben Objekte mit diesen Eigenschaften unter StarterGui, setz auch dort ResetOnSpawn des ScreenGui auf false, und behalte eine Karte als Vorlage, die das LocalScript für jedes Katalog-Item klont. Das Skript füllt dann nur die Karten aus und verbindet die Buttons. Die Kauflogik im nächsten Schritt ändert sich nicht.
Wenn dein Spiel mit einem Hauptmenü startet, gibt dir dieser Guide die eine Zeile für ShopClient, damit der Shop-Button erst erscheint, nachdem der Spieler auf Play gedrückt hat. Um den Shop stattdessen über ein Gespräch mit einem Händler zu öffnen, zeigt der Guide zu NPC-Dialogen, wie du eine Aktion OpenShop hinzufügst, die ShopClient sagt, sein Fenster zu öffnen, während Käufe weiter durch die eigenen Server-Prüfungen des Shops laufen.
Schritt 4: Käufe auf dem Server prüfen und abschließen
Dieses Script ist der einzige Ort, an dem ein Kauf passieren kann. Es bekommt die Item-id, prüft sie, schlägt den Preis nach, prüft die Coins des Spielers, zieht dann die Coins ab und gibt das Tool. Es antwortet dem Buy-Button mit true oder false und einer Nachricht zum Anzeigen.
Fahr mit der Maus über ServerScriptService, füge ein Script namens ShopService ein und füge das hier ein:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Was das Modul ShopCatalog zurückgibt, damit die strikte Typprüfung die Felder prüfen kann, die wir nutzen
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: Der Spieler kann das Tool sofort benutzen
local backpack = player:FindFirstChildOfClass("Backpack")
if backpack then
template:Clone().Parent = backpack
end
-- StarterGear: Roblox kopiert es bei jedem Spawn des Charakters wieder in den Backpack
local starterGear = player:FindFirstChildOfClass("StarterGear")
if starterGear then
template:Clone().Parent = starterGear
end
end
local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
-- 1. Der Client schickt nur eine Item-id, also muss es ein string sein
if type(itemId) ~= "string" then
return false, "That item does not exist."
end
-- 2. Doppelklicks und per Skript geflutete Anfragen ignorieren
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. Das Item in der eigenen Kopie des Katalogs auf dem Server nachschlagen
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. Der Preis kommt aus dem Katalog, nie vom Client
if coins.Value < item.price then
return false, `You need {item.price - coins.Value} more coins.`
end
-- 5. Coins abziehen, dann das Item geben. Hier wartet nichts (kein yield), also können zwei Anfragen
-- desselben Spielers nicht beide die Prüfungen oben bestehen, bevor das hier läuft.
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)
Besitz wird als Player-Attribut wie Owns_sword gespeichert. Attribute, die der Server setzt, werden auf das Gerät des Spielers repliziert, also kann das LocalScript diese Karte auf "Owned" umstellen. Eine Änderung, die ein Spieler an seiner eigenen Kopie macht, kommt nie beim Server an.
Das Tool landet an zwei Stellen. Die Kopie im Backpack erscheint sofort in der Hotbar. Die Kopie in StarterGear ist das, was Roblox bei jedem Spawn des Charakters in den neuen Backpack legt. Ohne sie verschwindet ein gekauftes Item, sobald der Spieler das erste Mal stirbt.
Warum der Client nie den Preis schickt
Alles auf dem Gerät eines Spielers kann dieser Spieler ändern. Exploiter führen ihren eigenen Code in ihrer Kopie des Spiels aus: Sie können deine LocalScripts lesen, das GUI bearbeiten und BuyItem:InvokeServer() mit beliebigen Argumenten aufrufen, so oft sie wollen. Der Security-Guide von Roblox sagt, dass du Typ und Wert von allem prüfen sollst, was ein Remote bekommt, und nimmt einen Shop als Beispiel.
| Ein Exploiter schickt | Wenn der Server ihm vertrauen würde | Was ShopService macht |
|---|---|---|
| Einen Preis von 0 | Jedes Item ist gratis | Ignoriert ihn. Der Preis kommt aus dem Katalog. |
| Einen Preis von -1000 | Coins.Value -= -1000 gibt ihm 1.000 Coins | Ignoriert ihn. |
NaN als Preis | Jeder Vergleich mit NaN ist false, also greift eine Prüfung auf "nicht genug Coins" nie | Ignoriert ihn. |
| Eine id, die nicht im Katalog steht, oder eine Tabelle statt eines Strings | Skriptfehler, oder Items, die du nie verkaufen wolltest | Antwortet "That item does not exist." |
| Hunderte Anfragen pro Sekunde | Serverlast, und jede Lücke in deinen Prüfungen wird hunderte Male getroffen | Bearbeitet höchstens eine Anfrage pro Spieler pro halbe Sekunde. |
| Auf dem eigenen Bildschirm bearbeitete Coins | Käufe mit Coins, die er nicht hat | Sieht das nie. Der Server liest nur seinen eigenen Coins-Wert. |
Die Regel gilt für jedes Remote, das du schreibst: Schick, was der Spieler gewählt hat, etwa eine Item-id oder eine Slot-Nummer, nie, was es kostet oder was er bekommen soll. Der Guide zu RemoteEvents geht genauer darauf ein, wie du Remote-Argumente prüfst.
Schritt 5: Den Shop testen
- Drück auf Play. Links erscheint ein Shop-Button. Öffne ihn und kauf die Flashlight: Deine Coins sinken um 25, das Tool erscheint in deiner Hotbar und sein Button wechselt zu Owned.
- Probier die Speed Coil, die 300 kostet. Die Statuszeile sagt, wie viele Coins dir noch fehlen, und es wird nichts abgezogen.
- Setz deinen Charakter über das Menü im Spiel zurück. Die Flashlight kommt im neuen Backpack zurück, dank der Kopie in StarterGear.
- Um dir beim Testen mehr Coins zu geben, klick auf den Umschalter Client/Server, um zu Server zu wechseln, such im Explorer
Players, deinen Namen,leaderstats,Coinsund ändere im Properties-Fenster den Value. Dasselbe im Client-Modus ändert nur deinen Bildschirm, und genau diese Art Änderung ignoriert der Server.
Wenn ein Button "The shop did not answer" antwortet, öffne das Output-Fenster über das Menü Window von Studio und such nach einem roten Fehler von ShopService. Bleibt ein Button stattdessen bei "Buying..." stehen, läuft ShopService nicht oder wartet auf ein Objekt: siehe Häufige Fehler.
Einen Game Pass für Robux verkaufen
Coins sind deine eigene Währung, also entscheidet der Shop oben jeden Kauf selbst. Dinge, die ein Spieler mit Robux kauft, funktionieren anders: Ein Game Pass wird einmal gekauft und behalten (VIP-Vorteile, ein dauerhaftes Tool), und ein Developer Product kann immer wieder gekauft werden (ein Coin-Paket, ein Skip). Beide laufen über MarketplaceService von Roblox, und die Zahlung nimmt Roblox an, nicht dein Skript.
Zwei Regeln aus diesem Guide gelten weiter: Zeig das Kaufangebot über einen Button auf dem Client an, und gib den Vorteil nur auf dem Server, sobald Roblox den Kauf bestätigt oder der Spieler den Pass schon besitzt. Der Guide zum Roblox Game-Pass-Skript (auf Englisch) baut das komplett, mit Besitzprüfung beim Beitreten, dem Kaufangebot, Vorteilen wie einer VIP-Tür und der Frage, wann stattdessen ein Developer Product passt. Um einen Preis festzulegen, zeigt der kostenlose Robux-Steuerrechner (auf Englisch), was ein Pass oder Developer Product dir nach dem Anteil von Roblox einbringt.
Speichern, was Spieler gekauft haben
Alles bisher hält nur eine Sitzung lang: Coins und gekaufte Items werden zurückgesetzt, wenn der Spieler geht, bis du sie mit einem Data Store speicherst. Statt den Speichercode hier zu wiederholen, folge dem DataStore-Tutorial (oder Schritt 3 im Leaderboard-Guide für eine kürzere Version) und denk an diese Shop-Regeln:
- Speichere Item-ids wie
{ "sword", "flashlight" }in derselben Tabelle wie den Coins-Wert, damit ein Speichervorgang sowohl die ausgegebenen Coins als auch das gekaufte Item festhält. Tools und andere Instanzen lassen sich nicht in einem Data Store speichern. - Wenn die Daten laden, geh die gespeicherten ids durch, überspring alle, die der Katalog nicht mehr hat, setz jedes
Owns_-Attribut und gib das Tool genauso wiegiveTool. Das Shop-Fenster aktualisiert sich von selbst, weil es auf diese Attribute hört. - Pass-Besitz muss nicht gespeichert werden:
UserOwnsGamePassAsyncfragt Roblox bei jedem Beitritt des Spielers. - Speichere nie einen Spieler, dessen Daten nicht geladen werden konnten, sonst kann ein fehlgeschlagenes Laden seine Käufe durch eine leere Liste ersetzen.
Häufige Fehler und Lösungen
Wenn der Shop sich falsch verhält, prüf zuerst diese Punkte. Öffne vor allem anderen das Output-Fenster (Menü Window, dann Output): Ein Skriptfehler nennt das Skript und die Zeile.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'
Ein Skript wartet auf ein Objekt, das es unter genau diesem Namen nicht gibt. Prüf Schreibweise und Großbuchstaben von ShopRemotes, BuyItem, ShopCatalog und ShopItems, und dass ShopItems in ServerStorage liegt, nicht in ReplicatedStorage. Der Guide zu Skriptfehlern erklärt diese Warnung ausführlich.
Ein Buy-Button bleibt bei "Buying..." stehen und antwortet nie
Nichts auf dem Server hat BuyItem.OnServerInvoke gesetzt, also hält Roblox die Anfrage fest, bis es etwas tut. Stell sicher, dass ShopService ein Script ist, kein LocalScript, und in ServerScriptService liegt, und such in Output nach einer Warnung Infinite yield possible von ShopService: Dann wartet das Skript auf ShopCatalog, ShopRemotes oder ShopItems.
Ein Buy-Button sagt "The shop did not answer"
Der Aufruf an den Server ist fehlgeschlagen, statt eine Antwort zurückzugeben. Der übliche Grund ist ein Fehler in ShopService beim Bearbeiten der Anfrage, also such in Output nach einem roten Fehler von ShopService: Er nennt die Zeile.
Ein Button sagt "This item is not available right now"
Der Server hat in ServerStorage, ShopItems kein Tool mit dem toolName dieses Items gefunden. Output zeigt eine Warnung mit dem genauen Namen, nach dem er gesucht hat.
Ich habe ein Tool gekauft, aber mein Charakter kann es nicht halten oder bleibt hängen
Ein Tool braucht genau einen Part namens Handle als direktes Kind, und keiner seiner Parts darf verankert sein. Für ein Tool, das nichts zum Festhalten hat, entferne stattdessen den Haken bei RequiresHandle.
Die Coins sind auf meinem Bildschirm gesunken, aber für niemand anderen
Der Kauf lief in einem LocalScript, also hat sich nur dein Gerät geändert. Verschieb das Abziehen der Coins und das Geben des Tools in ein Server-Script, wie in Schritt 4.
Gekaufte Items sind weg, nachdem ich wieder beitrete
Noch wird nichts gespeichert. Siehe Speichern, was Spieler gekauft haben.
Mit RoCode bauen
Wenn du das lieber nicht von Hand verkabeln willst, kann RoCode es in dem Spiel bauen, das du offen hast. Es ist ein unabhängiger KI-Coding-Agent: Du beschreibst die Funktion in seinem Webchat, und sein Roblox-Studio-Plugin erstellt die Skripte, das Remote und das GUI in deinem Explorer, also kopierst du keinen Code aus einem Chatfenster. Prompts kannst du auf Deutsch schreiben.
Füge einen Coin-Shop hinzu: einen Shop-Button, der ein Raster mit vier Tools öffnet, deren Preise in den Coins aus meinen leaderstats stehen. Der Server soll den Preis prüfen und das Tool in den Backpack und das StarterGear geben.
- Kann dein Spiel mit Search Scripts und Read Script nach vorhandenen leaderstats und Shop-Code durchsuchen, damit es deinen Coins-Wert weiterverwendet, statt einen zweiten hinzuzufügen
- Kann das Fenster mit Build UI vorbauen, dessen Shop-Layout mit Platzhalter-Item-Karten und einem LocalScript für Hover-Effekte und den Close-Button kommt; die Kauflogik wird als eigene Skripte geschrieben
- Erstellt die RemoteFunction mit Create Instance und schreibt das Katalog-ModuleScript, das Server-Script und das LocalScript mit Create Script
- Prüft jedes Skript in Studio mit Check Script auf Kompilierfehler (es prüft keine Typen und führt nichts aus), und jede Änderungsrunde ist ein Undo-Punkt in Studio
Einen Pass erstellst du weiter selbst im Creator Hub, weil RoCode keine Passes oder Developer Products erstellen kann, und die Käufe testest du selbst: Mit Plugin 3.9 oder neuer kann RoCode einen kurzen Playtest machen und die Fehler lesen, und mit Plugin 3.9.15 oder neuer kann sein Test-Charakter die Shop- und Buy-Buttons anklicken, aber es prüft nur, was es selbst zum Testen ausgewählt hat. Ein Shop kommt meist nach dem Kern-Gameplay und dem Speichern; der Ablauf Schritt für Schritt, um mit RoCode ein Spiel zu bauen zeigt, wo er hingehört. Wie sich RoCode mit Studio verbindet.
Häufige Fragen
Soll der Buy-Button ein RemoteEvent oder eine RemoteFunction nutzen?
Beides geht, solange der Server prüft. Mit einer RemoteFunction kann der Button auf die Antwort des Servers warten und sie anzeigen, deshalb nutzt dieser Guide eine, und auch der Security-Guide von Roblox nimmt für sein Shop-Beispiel eine RemoteFunction. Ruf sie nur vom Client aus auf: Ein Server, der InvokeClient aufruft, kann ewig warten, wenn der Client nie antwortet. Der Guide zu RemoteEvents vergleicht beide.
Wie öffne ich den Shop über einen NPC statt über einen Button?
Leg ein ProximityPrompt in einen Part des NPCs, etwa seinen HumanoidRootPart, hör in einem Server-Script auf sein Event Triggered und feuer ein RemoteEvent an diesen Spieler, damit das LocalScript das Panel zeigt. Wenn Kaufen nur in der Nähe des NPCs gehen soll, prüf zusätzlich im BuyItem-Handler die Entfernung zum NPC, weil ein Client das Remote von überall aufrufen kann.
Wie verkaufe ich Items, die Spieler mehrmals kaufen können?
Lass für diese Items die Prüfung "besitzt du schon" weg und gib statt eines Tools etwas Zählbares, zum Beispiel 1 mehr in einem IntValue, das Tränke zählt. Lass das Nachschlagen des Preises und die Coins-Prüfung genau so, wie sie sind.
Warum verschwindet mein Shop, wenn mein Charakter respawnt?
Sein ScreenGui hat ResetOnSpawn auf true, den Standardwert, also löscht Roblox es beim Respawn. Setz es auf false, wie es das Skript in Schritt 3 macht.
Kann ich eine kostenlose Shop-GUI-Vorlage nutzen?
Ja, jedes Layout funktioniert, solange seine Buy-Buttons nur eine Item-id schicken und der Kauf selbst in einem Server-Script wie ShopService passiert. Prüf vor dem Nutzen einer Vorlage ihre Skripte darauf, ob Coins in einem LocalScript abgezogen oder Items darin gegeben werden.
Quellen und weiterführende Links
- Roblox Creator Docs: Securing the client-server boundary (auf Englisch). Remote-Argumente prüfen, NaN, Rate Limiting und das Shop-Beispiel im Spiel
- Roblox Creator Docs: Remote events and callbacks (auf Englisch). RemoteFunction, InvokeServer, OnServerInvoke und die Risiken von InvokeClient
- Roblox Creator Docs: Passes (auf Englisch). Passes erstellen und verkaufen, UserOwnsGamePassAsync und PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (auf Englisch). der automatisch erstellte Shop von Roblox im Spiel
- Roblox Creator Docs: Developer Products (auf Englisch). wiederholbare Robux-Käufe und ProcessReceipt
- Roblox Creator Docs: StarterGear (auf Englisch). warum ein Tool in StarterGear nach einem Respawn zurückkommt
- Roblox Creator Docs: In-game tools (auf Englisch). Handles, Verankern und RequiresHandle
So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 14. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.