בקצרה
שמרו את הפריטים והמחירים ב-ModuleScript ב-ReplicatedStorage, בנו את החלון מ-ScreenGui, ScrollingFrame ו-UIGridLayout, ותנו לכל כפתור Buy לקרוא ל-RemoteFunction ולהעביר רק את ה-id של הפריט. משם Script ב-ServerScriptService מוצא בעצמו את המחיר, בודק ומוריד את ה-Coins של השחקן ונותן את הפריט.
- אף פעם אל תתנו ללקוח לשלוח את המחיר. כל אחד יכול להפעיל את ה-remotes שלכם עם כל ערך, ולכן השרת לוקח את המחיר מהעותק שלו של הקטלוג.
- את ה-Tool שנקנה תנו על ידי שכפול מ-ServerStorage ל-Backpack של השחקן (כדי להשתמש מיד) ול-StarterGear (כדי שיחזור אחרי לידה מחדש).
- מה שנמכר ב-Robux הוא passes ו-developer products, ואיתם עובד MarketplaceService. בשבילם Roblox גם יוצרת בעצמה Shop, וזה לא אותו דבר כמו חנות במטבעות.
בעמוד הזה
איך חנות שעובדת בנויה
חנות שעובדת במשחק אמיתי מחולקת בין המכשיר של השחקן לשרת. המכשיר מצייר את החלון ואומר "אני רוצה לקנות חרב". השרת, הצד היחיד שאפשר לסמוך עליו, מחליט אם זה יקרה. סקריפטי חנות ש"לא עובדים", או ששחקנים שוברים עם רמאויות, מקבלים לעיתים קרובות את ההחלטה הזו בצד הלא נכון.
| חלק | איפה הוא נמצא | מה הוא עושה |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | id של פריטים, שמות, מחירים וה-Tool שכל אחד נותן. שני הצדדים קוראים אותו. |
RemoteFunction BuyItem | ReplicatedStorage, בתיקייה ShopRemotes | נושא את בקשת הקנייה לשרת ואת התשובה בחזרה. |
LocalScript ShopClient | StarterPlayerScripts | בונה את חלון החנות ושולח את ה-id של הפריט כשלוחצים על כפתור Buy. |
Script ShopService | ServerScriptService | בודק את הבקשה, מוריד Coins ונותן את ה-Tool. |
| ה-Tools שאתם מוכרים | ServerStorage, בתיקייה ShopItems | המקורות שהשרת מעתיק. שום דבר מ-ServerStorage לא נשלח לשחקנים. |
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
שלב 1: מטבעות ופריטים למכירה
החנות מוציאה את הערך Coins ב-leaderstats של השחקן. אם עברתם את המדריך לטבלת מובילים, הוא כבר קיים אצלכם, ואפשר לדלג על הסקריפט הזה. אחרת הכניסו Script ל-ServerScriptService בשם Leaderstats. הוא נותן לכל אחד 200 מטבעות בהתחלה, כדי שאפשר יהיה לבדוק קניות מיד.
local Players = game:GetService("Players")
local STARTING_COINS = 200 -- מספיק לבדיקת החנות; קבעו 0 כששחקנים יוכלו להרוויח מטבעות
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
השאירו רק סקריפט leaderstats אחד. שני סקריפטים שכל אחד מהם יוצר תיקיית leaderstats נותנים לכל שחקן שתי תיקיות, והחנות עלולה לקרוא את הלא נכונה.
אחר כך צרו את האובייקטים שהסקריפטים מחפשים. אותיות גדולות וקטנות בשמות חשובות, אז כתבו אותם בדיוק כמו כאן.
- ב-Explorer רחפו מעל ReplicatedStorage, לחצו על כפתור ה-+ והכניסו Folder בשם
ShopRemotes. בתוכה הכניסו RemoteFunction בשםBuyItem. - רחפו מעל ServerStorage והכניסו Folder בשם
ShopItems. - שימו ב-ShopItems Tool לכל פריט, בשמות
ClassicSword,Flashlight,GrappleHookו-SpeedCoil. לבדיקה הראשונה מספיק ב-Tool Part אחד לא מעוגן בשםHandle. מתאים גם כל Tool שכבר יש לכם: תנו לו את השם הנכון. נשק שבאמת גורם נזק בנו לפי המדריך לחרב או המדריך לרובה; בכל אחד כתוב איך לחבר אותו לקטלוג. - סמנו כל Tool והסירו את הסימון מ-CanBeDropped בחלון Properties. כשהוא מסומן, לחיצה על Backspace זורקת את הכלי ל-Workspace, וכל שחקן יכול לאסוף את מה שהקונה שילם עליו.
אפשר להתחיל עם Tool אחד בלבד. אם חסר Tool של פריט, השרת מסרב למכור את הפריט הזה ומדפיס אזהרה עם השם שלו, כך ששום דבר לא יורד לשחקן.
שלב 2: פריטים ומחירים בקטלוג
הקטלוג הוא הרשימה היחידה של כל מה שהחנות מוכרת. ה-LocalScript קורא אותו כדי לצייר את הכרטיסים, והשרת קורא אותו כדי למצוא מחירים, ולכן שינוי מחיר הוא עריכה אחת במקום אחד.
רחפו מעל ReplicatedStorage, הכניסו ModuleScript, שנו את השם שלו ל-ShopCatalog והחליפו את התוכן בזה:
export type ShopItem = {
id: string, -- אחר כך נשמר במאגר הנתונים: אל תשנו אותו כשהפריט כבר אצל שחקנים
name: string, -- מוצג על הכרטיס; מותר לשנות
price: number, -- ב-Coins
description: string,
toolName: string, -- ה-Tool ב-ServerStorage.ShopItems שהשחקן מקבל
}
-- הכרטיסים מופיעים לפי הסדר הזה
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
-- מחזיר את הפריט עם ה-id הזה, או nil אם אין פריט כזה
function ShopCatalog.get(id: string): ShopItem?
return byId[id]
end
-- Attribute של Player שהשרת קובע ל-true כשהפריט אצל השחקן
function ShopCatalog.ownedAttribute(id: string): string
return "Owns_" .. id
end
return ShopCatalog
לכל פריט יש id ובנפרד name לתצוגה. השרת רושם דווקא את ה-id כשמשהו אצל השחקן, ולכן אפשר אחר כך לשנות את השם "Classic Sword" בלי לשבור קניות שמורות. התיאורים הם רק טקסט על הכרטיס; מה ה-Tool עושה, מחליטים הסקריפטים שלו עצמו.
שחקנים יכולים לקרוא ModuleScript ב-ReplicatedStorage, כך שהמחירים האלה ציבוריים. זה בסדר: הם ממילא כתובים על הכרטיסים. מה שחשוב הוא שהלקוח והשרת מריצים כל אחד עותק משלו של המודול, ולכן שחקן ששינה מחירים במכשיר שלו לא משנה כלום בשרת.
שלב 3: בונים את ה-GUI של החנות
ה-LocalScript הזה בונה את כל החלון בקוד: כפתור Shop, חלונית עם רשת נגללת של כרטיסים, כפתור Buy לכל פריט בקטלוג, מונה Coins ושורת סטטוס לתשובות של השרת. מכיוון שהכול עשוי בקוד, אפשר להדביק אותו וללחוץ על Play. בטבלה שאחריו מפורט כל אובייקט, אם אתם רוצים לסדר את החלון ביד.
- ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts והכניסו LocalScript בשם
ShopClient. - החליפו את התוכן שלו בקוד שלמטה.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- מה המודול ShopCatalog מחזיר, כדי שבדיקת הטיפוסים המחמירה תבדוק את השדות שאנחנו משתמשים בהם
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: מחזיק את כל מה שהחנות מציירת במסך של השחקן
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- החנות נשארת כשהדמות נולדת מחדש
-- כפתור בקצה השמאלי שפותח וסוגר את החנות
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)
-- חלון החנות: במרכז, מוסתר עד שהשחקן פותח אותו
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) -- לא נותן לחלון להיות ענק במסכים גדולים
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
-- כאן מוצגות התשובות של השרת, למשל "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: אזור שנגלל כשיש יותר כרטיסים ממה שנכנס
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() -- מתחיל מאפס; AutomaticCanvasSize מותח אותו לפי הכרטיסים
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel
-- UIGridLayout: מסדר את הכרטיסים בשורות ומעביר אותם לשורה הבאה
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..."
-- שולחים רק את ה-id של הפריט. את המחיר השרת מוצא בעצמו.
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)
-- השרת קובע את ה-Attribute הזה כשהקנייה עברה (או כשהפריטים השמורים נטענו)
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")
-- מציגים את המטבעות של השחקן. הערך האמיתי אצל השרת; כאן הוא רק מוצג.
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()
הכפתורים משתמשים ב-Activated, לא ב-MouseButton1Click: הוא נורה בלחיצת עכבר, בנגיעה בטלפון ובכפתור A או איקס בג׳ויפד.
הגדרות ה-type למעלה מתארות מה ShopCatalog מחזיר, כדי שבדיקת הטיפוסים המחמירה תתפוס שגיאת הקלדה בשדה, למשל item.prise. כשהמשחק רץ, הן לא משנות כלום.
| אובייקט | התפקיד בחנות | המאפיינים העיקריים |
|---|---|---|
ScreenGui | מחזיק את כל מה שמצויר במסך | ResetOnSpawn false, כדי שהחנות תשרוד לידה מחדש |
Frame | החלון וכל כרטיס פריט | AnchorPoint 0.5, 0.5 ו-Position 0.5, 0.5, כדי שהחלון יהיה במרכז |
UISizeConstraint | מגביל את החלון במסכים גדולים | MaxSize 640 על 460 |
ScrollingFrame | נגלל כשיש יותר כרטיסים ממה שנכנס | CanvasSize 0 ו-AutomaticCanvasSize Y, כדי שאזור הגלילה יגדל יחד עם הכרטיסים |
UIGridLayout | מעמיד כרטיסים בשורות ומעביר אותם | CellSize 180 על 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | מעגל פינות | CornerRadius בין 8 ל-14 פיקסלים |
UIPadding | ריווח פנימי | בין 10 ל-12 פיקסלים מכל צד |
TextButton | כפתורי Shop, סגירה ו-Buy | האירוע Activated |
אם אתם רוצים לצייר את החלון ביד, בנו את אותם אובייקטים ב-StarterGui עם המאפיינים האלה, גם שם קבעו את ResetOnSpawn של ה-ScreenGui ל-false, והשאירו כרטיס אחד כתבנית שה-LocalScript משכפל לכל פריט בקטלוג. אז הסקריפט רק ממלא את הכרטיסים ומחבר את הכפתורים. לוגיקת הקנייה בשלב הבא לא משתנה.
אם המשחק שלכם מתחיל בתפריט ראשי, במדריך ההוא יש שורה אחת שצריך להוסיף ל-ShopClient, כדי שכפתור ה-Shop יופיע רק אחרי שהשחקן לחץ על Play. כדי שהחנות תיפתח בשיחה עם מוכר, המדריך לדיאלוג עם NPC מראה איך מוסיפים פעולה OpenShop שאומרת ל-ShopClient לפתוח את החלון, והקניות עדיין עוברות דרך בדיקות השרת של החנות.
שלב 4: בדיקה וקנייה בשרת
ה-Script הזה הוא המקום היחיד שבו קנייה יכולה לקרות. הוא מקבל את ה-id של הפריט, בודק אותו, מוצא את המחיר, בודק את ה-Coins של השחקן, ואז מוריד את המטבעות ונותן את ה-Tool. לכפתור ה-Buy הוא עונה true או false והודעה להצגה.
רחפו מעל ServerScriptService, הכניסו Script בשם ShopService והדביקו בו את זה:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- מה המודול ShopCatalog מחזיר, כדי שבדיקת הטיפוסים המחמירה תבדוק את השדות שאנחנו משתמשים בהם
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: השחקן יכול להשתמש בכלי מיד
local backpack = player:FindFirstChildOfClass("Backpack")
if backpack then
template:Clone().Parent = backpack
end
-- StarterGear: Roblox מעתיקה אותו מחדש ל-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. הלקוח שולח רק id של פריט, כלומר זו חייבת להיות מחרוזת
if type(itemId) ~= "string" then
return false, "That item does not exist."
end
-- 2. מתעלמים מלחיצות כפולות ומזרמי בקשות מסקריפטים
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. מחפשים את הפריט בעותק של הקטלוג בשרת עצמו
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. המחיר לקוח מהקטלוג ואף פעם לא מהלקוח
if coins.Value < item.price then
return false, `You need {item.price - coins.Value} more coins.`
end
-- 5. מורידים מטבעות, ואז נותנים את הפריט. כאן שום דבר לא מוותר על הביצוע, ולכן שתי בקשות
-- מאותו שחקן לא יכולות לעבור שתיהן את הבדיקות שלמעלה לפני שזה רץ.
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)
הבעלות נשמרת כ-Attribute של Player, למשל Owns_sword. Attributes שהשרת קובע משוכפלים למכשיר של השחקן, ולכן LocalScript יכול להעביר את הכרטיס ל-"Owned". שינוי שהשחקן עושה בעותק שלו לא מגיע לשרת.
ה-Tool נכנס לשני מקומות. העותק ב-Backpack מופיע מיד בסרגל הכלים. את העותק ב-StarterGear Roblox שמה ב-Backpack החדש בכל פעם שהדמות מופיעה. בלעדיו, הפריט שנקנה ייעלם במוות הראשון של השחקן.
למה הלקוח אף פעם לא שולח מחיר
כל מה שנמצא במכשיר של השחקן, השחקן הזה יכול לשנות. רמאים מריצים קוד משלהם בעותק שלהם של המשחק: הם יכולים לקרוא את ה-LocalScripts שלכם, לשנות את ה-GUI ולקרוא ל-BuyItem:InvokeServer() עם כל ארגומנט כמה פעמים שירצו. מדריך האבטחה של Roblox אומר לבדוק גם את הסוג וגם את הערך של כל מה ש-remote מקבל, והדוגמה שם היא בדיוק חנות.
| רמאי שולח | אם השרת היה מאמין לו | מה ShopService עושה |
|---|---|---|
| מחיר 0 | כל הפריטים בחינם | מתעלם ממנו. המחיר לקוח מהקטלוג. |
| מחיר 1000- | Coins.Value -= -1000 נותן לו 1,000 מטבעות | מתעלם ממנו. |
NaN במקום מחיר | כל השוואה עם NaN היא שקר, ולכן הבדיקה "אין מספיק מטבעות" אף פעם לא נורית | מתעלם ממנו. |
| id שלא קיים בקטלוג, או טבלה במקום מחרוזת | שגיאות בסקריפט או פריטים שלא התכוונתם למכור | עונה "That item does not exist." |
| מאות בקשות בשנייה | עומס על השרת, וכל חור בבדיקות נורה מאות פעמים | מטפל בלא יותר מבקשה אחת לשחקן כל חצי שנייה. |
| Coins ששונו במסך שלו | קניות במטבעות שאין לו | לא רואה את זה בכלל. השרת קורא רק את ערך ה-Coins שלו. |
הכלל הזה מתאים לכל remote שאתם כותבים: שלחו את מה שהשחקן בחר, למשל id של פריט או מספר משבצת, ואף פעם לא כמה זה עולה או מה הוא צריך לקבל. המדריך ל-RemoteEvent מפרט יותר את בדיקת הארגומנטים של remotes.
שלב 5: בודקים את החנות
- לחצו על Play. משמאל יופיע כפתור Shop. פתחו אותו וקנו Flashlight: ה-Coins יירדו ב-25, הכלי יופיע בסרגל הכלים, והכפתור שלו יתחלף ל-Owned.
- נסו את Speed Coil, שעולה 300. שורת הסטטוס תכתוב כמה מטבעות עוד חסרים, ושום דבר לא יירד.
- אפסו את הדמות דרך התפריט שבתוך המשחק. Flashlight יחזור ל-Backpack החדש בזכות העותק ב-StarterGear.
- כדי להוסיף לעצמכם מטבעות בזמן הבדיקה, לחצו על המתג Client/Server ועברו ל-Server, מצאו ב-Explorer את
Players, את השם שלכם, אתleaderstats, אתCoins, ושנו את ה-Value שלו בחלון Properties. אותו דבר במצב Client משנה רק את המסך שלכם, וזה בדיוק סוג השינוי שהשרת מתעלם ממנו.
אם הכפתור עונה "The shop did not answer", פתחו את חלון ה-Output דרך תפריט Window ב-Studio וחפשו שגיאה אדומה מ-ShopService. אם הכפתור תקוע על "Buying...", זה אומר ש-ShopService לא רץ או שנתקע בהמתנה לאובייקט: ראו שגיאות נפוצות.
מכירת Game Pass ב-Robux
מטבעות הם המטבע שלכם, ולכן החנות שלמעלה מחליטה בעצמה על כל קנייה. מה ששחקן קונה ב-Robux עובד אחרת: Game Pass נקנה פעם אחת ונשאר לתמיד (הטבות VIP, כלי קבוע), ו-developer product אפשר לקנות שוב ושוב (חבילת מטבעות, דילוג על שלב). שניהם עוברים דרך MarketplaceService של Roblox, ואת התשלום מקבלת Roblox, לא הסקריפט שלכם.
מהמדריך הזה עוברים שני כללים: הפעילו את חלון הקנייה מכפתור בלקוח, ואת ההטבה תנו רק בשרת, כש-Roblox אישרה את הקנייה או שה-pass כבר אצל השחקן. המדריך לסקריפט Game Pass בונה את זה כולו: בדיקת בעלות בכניסה, חלון קנייה, הטבות כמו דלת VIP, ומתי עדיף developer product במקום pass. כדי לבחור מחיר, מחשבון העמלה של Robux החינמי מראה כמה pass או developer product מכניסים לכם אחרי החלק של Roblox.
שומרים את הקניות של השחקנים
כל מה שעשינו חי סשן אחד: מטבעות ופריטים שנקנו מתאפסים כשהשחקן יוצא, עד שתשמרו אותם דרך מאגר נתונים. כדי לא לחזור כאן על קוד השמירה, עברו את המדריך ל-DataStore (או את שלב 3 במדריך לטבלת מובילים, שם הגרסה קצרה יותר), וזכרו את כללי החנות:
- שמרו את ה-id של הפריטים, למשל
{ "sword", "flashlight" }, באותה טבלה כמו ערך ה-Coins, כדי ששמירה אחת תכתוב גם את המטבעות שהוצאו וגם את הפריט שנקנה. Tool ו-instances אחרים אי אפשר לשים במאגר נתונים. - כשהנתונים נטענו, עברו על ה-id השמורים, דלגו על אלה שכבר לא בקטלוג, קבעו כל Attribute מסוג
Owns_ותנו את ה-Tool באותה דרך ש-giveToolעושה. חלון החנות יתעדכן לבד, כי הוא מאזין ל-Attributes האלה. - בעלות על pass לא צריך לשמור:
UserOwnsGamePassAsyncשואל את Roblox בכל פעם שהשחקן נכנס. - אף פעם אל תשמרו שחקן שהנתונים שלו לא נטענו, אחרת טעינה שנכשלה עלולה להחליף את הקניות שלו ברשימה ריקה.
שגיאות נפוצות ופתרונות
כשהחנות מתנהגת מוזר, בדקו קודם את זה. דבר ראשון פתחו את חלון ה-Output (תפריט Window, ואז Output): שגיאת סקריפט מציינת את הסקריפט ואת השורה.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'
הסקריפט מחכה לאובייקט שלא קיים בשם המדויק הזה. בדקו את האיות והאותיות הגדולות ב-ShopRemotes, ב-BuyItem, ב-ShopCatalog וב-ShopItems, ושה-ShopItems נמצא ב-ServerStorage, לא ב-ReplicatedStorage. המדריך לשגיאות בסקריפטים מפרט את האזהרה הזו.
כפתור ה-Buy תקוע על "Buying..." ולא עונה
בשרת אף אחד לא קבע את BuyItem.OnServerInvoke, ולכן Roblox מחזיקה את הבקשה עד שזה יקרה. ודאו ש-ShopService הוא Script, לא LocalScript, ונמצא ב-ServerScriptService, וחפשו ב-Output את האזהרה Infinite yield possible מ-ShopService: היא אומרת שהסקריפט נתקע בהמתנה ל-ShopCatalog, ל-ShopRemotes או ל-ShopItems.
כפתור ה-Buy כותב "The shop did not answer"
הקריאה לשרת נפלה, ולא החזירה תשובה. הסיבה הרגילה היא שגיאה בתוך ShopService בזמן הטיפול בבקשה, אז חפשו ב-Output שגיאה אדומה מ-ShopService: מצוינת בה השורה.
הכפתור כותב "This item is not available right now"
השרת לא מצא Tool עם ה-toolName של הפריט הזה בתוך ServerStorage, ShopItems. ב-Output יש אזהרה עם השם המדויק שהוא חיפש.
קניתי כלי, אבל הדמות לא יכולה להחזיק אותו או נתקעת
ל-Tool צריך להיות בדיוק Part אחד בשם Handle ישירות בפנים, ואף אחד מה-Parts שלו לא אמור להיות מעוגן. לכלי שלא צריך להחזיק ביד, הסירו במקום זה את הסימון מ-RequiresHandle.
המטבעות ירדו במסך שלי, אבל לא אצל האחרים
הקנייה עברה ב-LocalScript, ולכן השתנה רק המכשיר שלכם. העבירו את הורדת המטבעות ואת מתן ה-Tool ל-Script של שרת, כמו בשלב 4.
פריטים שנקנו נעלמים אחרי כניסה מחדש
בינתיים שום דבר לא נשמר. ראו שמירת קניות.
לעשות עם RoCode
אם לא בא לכם לבנות את כל זה ביד, RoCode יכול לעשות את זה בפלייס שפתוח אצלכם. זה סוכן AI עצמאי לקוד: אתם מתארים את הפיצ׳ר בצ׳אט שלו באתר, והפלאגין שלו ל-Roblox Studio יוצר סקריפטים, remote ו-GUI ב-Explorer שלכם, כך שלא צריך להעתיק קוד מחלון הצ׳אט.
תוסיף חנות במטבעות: כפתור Shop שפותח רשת של ארבעה כלים עם מחירים ב-Coins מה-leaderstats שלי. השרת צריך לבדוק את המחיר ולתת את הכלי ל-Backpack ול-StarterGear.
- יכול לסרוק את הפלייס שלכם עם Search Scripts ו-Read Script, בחיפוש אחרי leaderstats וקוד חנות שכבר קיימים, כדי להשתמש בערך ה-Coins שלכם ולא להוסיף שני
- יכול לבנות שלד של חלון עם Build UI: תבנית החנות מגיעה עם כרטיסי דמה ו-LocalScript לאפקטים בריחוף ולכפתור Close; את לוגיקת הקנייה כותבים בסקריפטים נפרדים
- יוצר RemoteFunction עם Create Instance, וכותב את ה-ModuleScript של הקטלוג, Script של שרת ו-LocalScript עם Create Script
- בודק את הקומפילציה של כל סקריפט ב-Studio עם Check Script (הוא לא בודק טיפוסים ולא מריץ סקריפטים), וכל קבוצת שינויים היא נקודת ביטול ב-Studio
את ה-passes עדיין תצטרכו ליצור ב-Creator Hub בעצמכם, כי RoCode לא יודע ליצור passes ו-developer products, וגם את הקניות בודקים אתם: עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.15 ומעלה דמות הבדיקה שלו יכולה ללחוץ על כפתורי Shop ו-Buy, אבל הוא בודק רק את מה שהוא עצמו החליט לבדוק. חנות בדרך כלל באה אחרי המשחקיות העיקרית והשמירה; מחזור יצירת המשחק צעד אחר צעד עם RoCode מראה איפה המקום שלה. איך RoCode מתחבר ל-Studio.
שאלות נפוצות
מה עדיף לכפתור Buy ב-Roblox: RemoteEvent או RemoteFunction?
שניהם מתאימים, אם השרת בודק. RemoteFunction מאפשרת לכפתור לחכות לתשובת השרת ולהציג אותה, ולכן המדריך משתמש בה, וגם במדריך האבטחה של Roblox דוגמת החנות היא על RemoteFunction. קראו לה רק מהלקוח: שרת שקורא ל-InvokeClient עלול לחכות לנצח אם הלקוח אף פעם לא יענה. המדריך ל-RemoteEvent משווה בין שתי האפשרויות.
איך פותחים את החנות דרך NPC, ולא בכפתור?
שימו ProximityPrompt באיזה Part של ה-NPC, למשל ב-HumanoidRootPart שלו, האזינו לאירוע Triggered שלו ב-Script של שרת, ושלחו לשחקן הזה RemoteEvent כדי שה-LocalScript יציג את החלונית. אם אפשר לקנות רק ליד ה-NPC, בדקו גם את המרחק ל-NPC בתוך ה-handler של BuyItem, כי הלקוח יכול להפעיל את ה-remote מכל מקום.
איך מוכרים פריטים שאפשר לקנות כמה פעמים?
לפריטים כאלה דלגו על הבדיקה "כבר יש", ותנו לא Tool אלא משהו שאפשר לספור, למשל הוסיפו 1 ל-IntValue שסופר שיקויים. את חיפוש המחיר ואת בדיקת המטבעות השאירו כמו שהם.
למה החנות נעלמת כשהדמות נולדת מחדש?
ב-ScreenGui שלה ResetOnSpawn קבוע ל-true, ערך ברירת המחדל, ולכן Roblox מוחקת אותה בלידה מחדש. קבעו false, כמו שהסקריפט בשלב 3 עושה.
אפשר לקחת תבנית GUI חינמית של חנות?
כן, כל פריסה מתאימה, אם כפתורי ה-Buy שלה שולחים רק את ה-id של הפריט, והקנייה עצמה קורית ב-Script של שרת כמו ShopService. לפני שלוקחים תבנית, בדקו שמטבעות לא יורדים ופריטים לא ניתנים ב-LocalScript.
מקורות וקריאה נוספת
- Roblox Creator Docs: Securing the client-server boundary (באנגלית). בדיקת ארגומנטים של remotes, NaN, הגבלת קצב ודוגמה של חנות במשחק
- Roblox Creator Docs: Remote events and callbacks (באנגלית). RemoteFunction, InvokeServer, OnServerInvoke והסיכונים של InvokeClient
- Roblox Creator Docs: Passes (באנגלית). יצירה ומכירה של passes, UserOwnsGamePassAsync ו-PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (באנגלית). ה-Shop שבתוך המשחק ש-Roblox יוצרת אוטומטית
- Roblox Creator Docs: Developer Products (באנגלית). קניות חוזרות ב-Robux ו-ProcessReceipt
- Roblox Creator Docs: StarterGear (באנגלית). למה Tool ב-StarterGear חוזר אחרי לידה מחדש
- Roblox Creator Docs: In-game tools (באנגלית). Handle, עיגון ו-RequiresHandle
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.