בקצרה
סימולטור ב-Roblox הוא לולאה אחת: לחצו כדי לקבל מטבעות, הוציאו אותם על שדרוגים שנותנים יותר, ואז עשו rebirth בשביל מכפיל קבוע. שמרו את המחירים ב-ModuleScript ב-ReplicatedStorage. Script אחד ב-ServerScriptService מחזיק לכל שחקן Coins, Click Power ו-Rebirths, סופר לא יותר מ-15 קליקים בשנייה מה-RemoteEvent בשם Click, ומוכר שדרוגים ו-rebirths דרך RemoteFunction אחרי בדיקת המחיר. LocalScript מציג את הכפתורים Click, Upgrade ו-Rebirth. עם המספרים מהמדריך הזה, שחקן שלוחץ 5 פעמים בשנייה מגיע ל-rebirth הראשון בערך תוך 1.2 דקות, וטבלת הקצב מראה מה לשנות כדי שהטיפוס יהיה ארוך יותר.
- קליק לא מעביר שום דבר חוץ מהקליק עצמו. כמה הוא שווה, השרת מחשב, ולכן לקוח מתוקן לא יכול לתת לעצמו מטבעות.
- שמרו את כל הטבלה לפי טיימר וכשהשחקן יוצא, לא בכל קליק. Roblox מתירה לכל שרת 60 + 40 × שחקנים כתיבות למאגר נתונים בדקה.
- לא יודעים לכתוב סקריפטים? את אותה לולאה יכולה לבנות ערכה מה-Creator Store, פלאגין או סוכן AI. בדקו שהשרת מחליט על המטבעות: אפשרויות.
- צריך חדר כושר או מכרה במקום כפתור? Tool יכול להפעיל את אותו remote בשם Click: הגרסה עם משקולת. אחר כך הוסיפו מערכות לפי סדר הבנייה שלמטה.
בעמוד הזה
איך לולאת הסימולטור העיקרית בנויה
סימולטור הוא לולאה של שלוש פעולות. השחקן עושה שוב ושוב משהו פשוט כדי להרוויח מטבע, מוציא אותו על שדרוגים שמביאים אותו מהר יותר, וכשהשדרוגים נעשים יקרים, עושה rebirth: מוותר על המטבעות והשדרוגים בתמורה לבונוס שנשאר לתמיד, ושוב מטפס, הפעם מהר יותר. בסימולטורים אחרים במקום קליק מרימים משקולות, חופרים או אוספים פריטים, אבל הלולאה שמתחת זהה.
| פעולה | כמה היא עולה | מה היא נותנת | מי מחליט |
|---|---|---|---|
| קליק | כלום | מטבעות ששווים Click Power × (Rebirths + 1) | השרת, שסופר לא יותר מ-15 קליקים בכל חלון באורך שנייה |
| שדרוג | 10 מטבעות, ואז פי 1.5 מהמחיר הקודם לכל רמה | עוד רמה אחת של Click Power, עד ה-50 | השרת, לפי העותק שלו של המחירים |
| Rebirth | 1,000 מטבעות, ואז פי 3 מהמחיר הקודם לכל rebirth | המטבעות חוזרים ל-0 ו-Click Power חוזר לרמה 1, ועוד 1+ קבוע למכפיל | השרת |
כל מספר חי בשרת. המכשיר של השחקן מצייר כפתורים ומבקש ("לחצתי", "אני רוצה שדרוג"), והשרת מחליט כמה זה עולה ואם אפשר לעשות את זה. סקריפטי קליקים שנפרצים מוסיפים לעיתים קרובות מטבעות ב-LocalScript, או נותנים ללקוח לשלוח כמה מטבעות להוסיף.
| רכיב | איפה הוא נמצא | מה הוא עושה |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | מחירים, מגבלות ונוסחאות לשווי קליק, מחיר שדרוג ומחיר rebirth. שני הצדדים קוראים אותו. |
Script SimulatorService | ServerScriptService | מחזיק את המספרים של כל שחקן, מטפל בקליקים, בשדרוגים וב-rebirths וממלא את leaderstats. |
Folder SimulatorRemotes | ReplicatedStorage (נוצר על ידי SimulatorService) | RemoteEvent בשם Click ו-RemoteFunctions בשם BuyUpgrade ו-Rebirth. |
LocalScript SimulatorClient | StarterPlayerScripts | בונה כפתורים, שולח קליקים ובקשות ומציג את המספרים של השרת. |
ModuleScript בשם PlayerData (לא חובה) | ServerScriptService | שומר התקדמות בין כניסות. הוא לקוח מהמדריך ל-DataStore ונחוץ רק לשלב 4. |
ReplicatedStorage
SimulatorConfig ModuleScript new
SimulatorRemotes Folder new
Click RemoteEvent new
BuyUpgrade RemoteFunction new
Rebirth RemoteFunction new
ServerScriptService
SimulatorService Script new
PlayerData ModuleScript
StarterPlayer
StarterPlayerScripts
SimulatorClient LocalScript new
שלב 1: הוציאו מחירים ונוסחאות למודול
כל מספר שאולי תרצו לכוונן נכנס ל-ModuleScript אחד: כמה שווה קליק, כמה עולה כל שדרוג ו-rebirth, ומגבלת הקליקים. השרת מחליט לפיו, וה-LocalScript לוקח ממנו מחירים לכפתורים, ולכן כל שינוי הוא עריכה אחת במקום אחד.
- ב-Explorer רחפו מעל ReplicatedStorage, לחצו על כפתור ה-+ והכניסו ModuleScript.
- שנו את השם שלו ל-
SimulatorConfig(השמות רגישים לאותיות גדולות וקטנות) והחליפו את התוכן שלו בקוד שלמטה.
-- כל המספרים של הלולאה העיקרית והנוסחאות ששני הצדדים משתמשים בהן. הלקוח רק
-- מציג לפיהם מחירים; השרת מחליט לפי העותק שלו.
local SimulatorConfig = {}
SimulatorConfig.UPGRADE_BASE_COST = 10 -- המחיר של Click Power ברמה 2
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- כל רמה עולה פי 1.5 מהקודמת
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- מטבעות ל-rebirth הראשון
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- כל rebirth עולה פי 3 מהקודם
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- קליקים מעבר לזה בשנייה אחת לא נספרים
-- מטבעות לקליק אחד: רמת ה-Click Power, כפול 1 ועוד מספר ה-rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
return powerLevel * (rebirths + 1)
end
-- המחיר של הרמה הבאה של Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end
-- המטבעות שצריך ל-rebirth הבא
function SimulatorConfig.rebirthCost(rebirths: number): number
return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end
return SimulatorConfig
שחקנים יכולים לקרוא ModuleScript ב-ReplicatedStorage, כך שהמחירים האלה ציבוריים. זה בסדר: הם ממילא כתובים על הכפתורים. הלקוח והשרת מריצים כל אחד עותק משלו של המודול, ולכן שחקן שישנה את המספרים במכשיר שלו לא ישנה כלום בשרת.
| רמת Click Power | מחיר הרמה הבאה | מטבעות לקליק, בלי rebirths | מטבעות לקליק, rebirth אחד |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
rebirths עולים 1,000 מטבעות, אחר כך 3,000, אחר כך 9,000, כי rebirthCost מכפיל כל פעם את המחיר ב-3. אחרי rebirth אחד כל קליק שווה כפול, אחרי שניים פי שלושה, וכן הלאה.
כמה זמן לוקח rebirth עם המספרים האלה
הנוסחאות קובעות כמה זמן הלולאה נמשכת, ולכן כדאי לחשב את המספרים לפני שהשחקנים יעשו את זה. הטבלה מניחה שהשחקן עושה rebirth ברגע שהוא יכול לשלם עליו, ובשאר הזמן קונה את הרמה הבאה של Click Power כשהוא יכול לשלם עליה והיא עולה פחות מ-rebirth. הזמן נספר מהתחלה חדשה, ולכן העמודה האחרונה היא הזמן הכולל עד 3 rebirths.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1,000 (המדריך הזה) | 1.2 | 2.7 | 4.8 |
| 5 000 | 4.3 | 10.1 | 18.3 |
| 10 000 | 8.2 | 16.9 | 33.2 |
| 25 000 | 16.7 | 40.1 | 74.5 |
| 50 000 | 32.8 | 68.8 | 137.8 |
בלי rebirths, רמת Click Power 5 מגיעה אחרי 34 קליקים, רמה 10 אחרי 122, ורמה 13 אחרי 285. עם מספרי ברירת המחדל השחקן מפסיק לשדרג אחרי זה, כי רמה 14 עולה 1,297 מטבעות, יותר מ-rebirth של 1,000 מטבעות, וה-rebirth הראשון מגיע אחרי 362 קליקים בסך הכול. עם מגבלת השרת של 15 קליקים בשנייה, חלקו כל זמן ב-3. אם תשנו מספר כלשהו ב-SimulatorConfig, הזמנים האלה ישתנו יחד איתו, אז חשבו אותם מחדש.
כוונון הצמיחה
שני המספרים מסוג _GROWTH קובעים כמה מהר המחירים עולים. ב-1.5 כל שדרוג עולה פי אחד וחצי מהקודם, וכל רמה מוסיפה רק מטבע אחד לקליק (לפני מכפיל ה-rebirths), כך שכל רמה חדשה מחזירה את עצמה לאט יותר. בדיוק ההאטה הזו הופכת את ה-rebirth לכדאי. העלו את הצמיחה לטיפוס ארוך יותר, הורידו אותה לטיפוס מהיר יותר, והשאירו את REBIRTH_BASE_COST גבוה מספיק, כדי ששחקנים יקנו כמה שדרוגים לפני ה-rebirth הראשון.
כדי שה-rebirth הראשון יהיה אחרי כמה דקות, ולא אחרי בערך אחת, העלו את REBIRTH_BASE_COST ל-5,000 או ל-10,000.
שלב 2: הוסיפו את סקריפט השרת
ה-Script הזה הוא הבעלים של כל מספר. הוא יוצר את ה-remotes, נותן לכל שחקן תיקיית leaderstats עם Coins ו-Rebirths, ועונה על שלוש בקשות. רחפו מעל ServerScriptService, הכניסו Script, שנו את השם שלו ל-SimulatorService והחליפו את התוכן בקוד הזה:
-- הבעלים של כל מספר: קליקים מביאים מטבעות כאן, שדרוגים ו-rebirths נקנים כאן,
-- ו-leaderstats רק מציג את התוצאה.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- false: בכל כניסה כולם מתחילים מאפס. true: טעינה ושמירה דרך המודול PlayerData
-- מהמדריך ל-DataStore (קודם הוסיפו PowerLevel = 1 ו-Rebirths = 0 ל-DEFAULTS שלו).
local SAVE_PROGRESS = false
type Config = {
MAX_POWER_LEVEL: number,
MAX_CLICKS_PER_SECOND: number,
clickValue: (powerLevel: number, rebirths: number) -> number,
upgradeCost: (powerLevel: number) -> number,
rebirthCost: (rebirths: number) -> number,
}
local Config = require(ReplicatedStorage:WaitForChild("SimulatorConfig")) :: Config
type Stats = { Coins: number, PowerLevel: number, Rebirths: number }
local remotes = Instance.new("Folder")
remotes.Name = "SimulatorRemotes"
local clickEvent = Instance.new("RemoteEvent")
clickEvent.Name = "Click"
clickEvent.Parent = remotes
local buyUpgrade = Instance.new("RemoteFunction")
buyUpgrade.Name = "BuyUpgrade"
buyUpgrade.Parent = remotes
local rebirthRemote = Instance.new("RemoteFunction")
rebirthRemote.Name = "Rebirth"
rebirthRemote.Parent = remotes
remotes.Parent = ReplicatedStorage
local playerStats: { [Player]: Stats } = {}
local windowStart: { [Player]: number } = {} -- מתי התחיל חלון השנייה הנוכחי של השחקן הזה
local clickCount: { [Player]: number } = {} -- קליקים שנספרו בחלון הזה
-- מעתיק את המספרים של השרת למקום שבו שחקנים רואים אותם: ל-leaderstats ול-Attribute אחד
local function refresh(player: Player)
local data = playerStats[player]
local leaderstats = player:FindFirstChild("leaderstats")
if not (data and leaderstats) then
return
end
local coins = leaderstats:FindFirstChild("Coins")
local rebirths = leaderstats:FindFirstChild("Rebirths")
if coins and coins:IsA("IntValue") then
coins.Value = data.Coins
end
if rebirths and rebirths:IsA("IntValue") then
rebirths.Value = data.Rebirths
end
player:SetAttribute("PowerLevel", data.PowerLevel)
end
-- מתחיל שחקן עם הנתונים שהועברו (מספרים חדשים או טבלה שמורה)
local function setup(player: Player, data: Stats)
playerStats[player] = data
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats"
for _, name in { "Coins", "Rebirths" } do
local value = Instance.new("IntValue")
value.Name = name
value.Parent = leaderstats
end
leaderstats.Parent = player
refresh(player)
end
-- קליק לא נושא מספרים: כמה הוא שווה, השרת מחשב
clickEvent.OnServerEvent:Connect(function(player: Player)
local data = playerStats[player]
if not data then
return
end
local now = os.clock()
local start = windowStart[player]
if not start or now - start >= 1 then
windowStart[player] = now
clickCount[player] = 0
end
local count = clickCount[player] or 0
if count >= Config.MAX_CLICKS_PER_SECOND then
return -- autoclicker או סקריפט שמפעיל את ה-remote בלולאה
end
clickCount[player] = count + 1
data.Coins += Config.clickValue(data.PowerLevel, data.Rebirths)
refresh(player)
end)
buyUpgrade.OnServerInvoke = function(player: Player): (boolean, string)
local data = playerStats[player]
if not data then
return false, "Your stats have not loaded yet."
end
if data.PowerLevel >= Config.MAX_POWER_LEVEL then
return false, "Click Power is maxed out."
end
local cost = Config.upgradeCost(data.PowerLevel)
if data.Coins < cost then
return false, `You need {cost - data.Coins} more coins.`
end
data.Coins -= cost
data.PowerLevel += 1
refresh(player)
return true, `Click Power is now level {data.PowerLevel}.`
end
rebirthRemote.OnServerInvoke = function(player: Player): (boolean, string)
local data = playerStats[player]
if not data then
return false, "Your stats have not loaded yet."
end
local cost = Config.rebirthCost(data.Rebirths)
if data.Coins < cost then
return false, `You need {cost - data.Coins} more coins to rebirth.`
end
-- rebirth מחליף מטבעות ושדרוגים במכפיל קבוע
data.Coins = 0
data.PowerLevel = 1
data.Rebirths += 1
refresh(player)
return true, `Rebirth {data.Rebirths}! Every click is now worth x{data.Rebirths + 1}.`
end
-- מספרי ההתחלה: חדשים, או הטבלה שהמודול PlayerData טוען ושומר
if SAVE_PROGRESS then
type PlayerDataModule = {
Loaded: RBXScriptSignal,
Get: (player: Player) -> any,
}
local PlayerData = require(ServerScriptService:WaitForChild("PlayerData")) :: PlayerDataModule
local function onLoaded(player: Player)
local data = PlayerData.Get(player)
if not data or playerStats[player] then
return
end
if type(data.Coins) ~= "number" or type(data.PowerLevel) ~= "number" or type(data.Rebirths) ~= "number" then
warn("SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module")
return
end
setup(player, data) -- אותה טבלה ש-PlayerData שומר, כך שכל שינוי נשמר
end
PlayerData.Loaded:Connect(onLoaded)
for _, player in Players:GetPlayers() do
onLoaded(player) -- כל מי שהנתונים שלו נטענו לפני שהסקריפט הזה רץ
end
else
local function onPlayerAdded(player: Player)
setup(player, { Coins = 0, PowerLevel = 1, Rebirths = 0 })
end
Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
onPlayerAdded(player)
end
end
Players.PlayerRemoving:Connect(function(player: Player)
playerStats[player] = nil
windowStart[player] = nil
clickCount[player] = nil
end)
Click Power מגיע לשחקן כ-Attribute בשם PowerLevel על אובייקט ה-Player שלו, ולא כערך שלישי ב-leaderstats, ולכן רשימת השחקנים מציגה רק את Coins ואת Rebirths. Attributes שהשרת קובע משוכפלים למכשיר של השחקן; שינוי שהשחקן יעשה במכשיר שלו נשאר שם.
קליקים ומגבלת קצב
ה-remote בשם Click לא מעביר ארגומנטים. בשרת, הפרמטר הראשון של ה-handler של OnServerEvent הוא תמיד השחקן שהפעיל אותו, ולכן השרת יודע מי לחץ, לוקח את רמת ה-Click Power ואת ה-Rebirths שלו ומוסיף clickValue ל-Coins שלו. בבקשה אין שום דבר שרמאי יכול לשנות.
במדריך האבטחה של Roblox כתוב אף פעם לא לסמוך רק על מגבלת קצב בלקוח, וחלוקת מטבע מופיעה שם בין הפעולות שצריך להגביל. השרת סופר את הקליקים של כל שחקן בחלונות של שנייה אחת: הקליק הראשון פותח חלון, וכש-15 קליקים נספרו, השאר לא נספרים עד שעוברת שנייה מתחילת החלון. סקריפט שמפעיל את ה-remote בלולאה מקבל לא יותר מ-15 קליקים שנספרו בכל חלון. כדי להתיר קליקים מהירים או איטיים יותר, שנו את MAX_CLICKS_PER_SECOND ב-SimulatorConfig.
שדרוגים ו-rebirths
BuyUpgrade ו-Rebirth הן RemoteFunctions, ולכן הכפתור יכול לחכות לתשובה ולהציג אותה. כל handler לוקח את המחיר מהעותק של SimulatorConfig בשרת, בודק את ה-Coins של השחקן, ורק אז משנה משהו. הוא מחזיר true או false והודעה, למשל "You need 5 more coins.", שה-LocalScript מציג בשורת הסטטוס.
בין בדיקת המחיר לשינוי שום דבר לא מחכה ולא מוותר על הביצוע (yield), ולכן שתי בקשות מאותו שחקן לא יכולות שתיהן לעבור את הבדיקה לפני שהראשונה לוקחת את המטבעות. rebirth קובע את Coins ל-0, את Click Power לרמה 1 ומוסיף 1 ל-Rebirths, ונוסחת הקליק הופכת את זה למכפיל Rebirths + 1.
המתג SAVE_PROGRESS
עם SAVE_PROGRESS = false כל שחקן מתחיל בכל כניסה עם 0 מטבעות, וזה מה שצריך בזמן שאתם בונים את המשחק. שלב 4 מפעיל אותו. אז הסקריפט מחכה שהמודול PlayerData יטען כל שחקן, ועובד ישירות עם הטבלה שהמודול הזה שומר, כך שכל מטבע וכל rebirth נשמרים בלי קוד נוסף.
שלב 3: בנו את הכפתורים
ה-LocalScript הזה בונה את כל המסך בקוד: מונה מטבעות למעלה, כפתור Click גדול באמצע, כפתורי Upgrade ו-Rebirth למטה ושורת סטטוס לתשובות של השרת. הוא עצמו אף פעם לא משנה אף מספר.
- ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts והכניסו LocalScript בשם
SimulatorClient. - החליפו את התוכן שלו בקוד שלמטה ולחצו על Play.
-- בונה את כפתורי הסימולטור ומציג את המספרים של השרת. הוא עצמו אף פעם לא משנה אותם.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TweenService = game:GetService("TweenService")
type Config = {
MAX_POWER_LEVEL: number,
clickValue: (powerLevel: number, rebirths: number) -> number,
upgradeCost: (powerLevel: number) -> number,
rebirthCost: (rebirths: number) -> number,
}
local Config = require(ReplicatedStorage:WaitForChild("SimulatorConfig")) :: Config
local remotes = ReplicatedStorage:WaitForChild("SimulatorRemotes")
local clickEvent = remotes:WaitForChild("Click") :: RemoteEvent
local buyUpgrade = remotes:WaitForChild("BuyUpgrade") :: RemoteFunction
local rebirthRemote = remotes:WaitForChild("Rebirth") :: RemoteFunction
local player = Players.LocalPlayer
local leaderstats = player:WaitForChild("leaderstats")
local coins = leaderstats:WaitForChild("Coins") :: IntValue
local rebirths = leaderstats:WaitForChild("Rebirths") :: IntValue
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)
-- 1234 -> "1.2K", 5600000 -> "5.6M"
local UNITS = {
{ size = 1e12, suffix = "T" },
{ size = 1e9, suffix = "B" },
{ size = 1e6, suffix = "M" },
{ size = 1e3, suffix = "K" },
}
local function short(n: number): string
for _, unit in UNITS do
if n >= unit.size then
return string.format("%.1f%s", math.floor(n / unit.size * 10) / 10, unit.suffix)
end
end
return tostring(n)
end
local function newButton(parent: Instance, text: string, position: UDim2, size: UDim2, color: Color3): TextButton
local button = Instance.new("TextButton")
button.AnchorPoint = Vector2.new(0.5, 0.5)
button.Position = position
button.Size = size
button.BackgroundColor3 = color
button.TextColor3 = Color3.new(1, 1, 1)
button.FontFace = BOLD
button.TextScaled = true
button.Text = text
button.Parent = parent
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 12)
corner.Parent = button
return button
end
local gui = Instance.new("ScreenGui")
gui.Name = "SimulatorGui"
gui.ResetOnSpawn = false
local coinsLabel = Instance.new("TextLabel")
coinsLabel.AnchorPoint = Vector2.new(0.5, 0)
coinsLabel.Position = UDim2.new(0.5, 0, 0, 12)
coinsLabel.Size = UDim2.fromOffset(320, 48)
coinsLabel.BackgroundTransparency = 1
coinsLabel.TextColor3 = Color3.fromRGB(255, 214, 90)
coinsLabel.FontFace = BOLD
coinsLabel.TextScaled = true
coinsLabel.Parent = gui
local clickButton = newButton(gui, "Click!", UDim2.new(0.5, 0, 0.5, -30), UDim2.fromScale(0.38, 0.38), Color3.fromRGB(124, 77, 255))
-- כפתור ה-Click נשאר ריבועי, לפי גודל המסך ולא גדול מ-200 על 200,
-- כדי שבטלפון ייכנס בין מונה המטבעות לכפתורים שלמטה
local square = Instance.new("UIAspectRatioConstraint")
square.Parent = clickButton
local maxSize = Instance.new("UISizeConstraint")
maxSize.MaxSize = Vector2.new(200, 200)
maxSize.Parent = clickButton
local upgradeButton = newButton(gui, "", UDim2.new(0.5, -110, 1, -60), UDim2.fromOffset(200, 56), Color3.fromRGB(40, 150, 90))
local rebirthButton = newButton(gui, "", UDim2.new(0.5, 110, 1, -60), UDim2.fromOffset(200, 56), Color3.fromRGB(200, 90, 40))
local status = Instance.new("TextLabel")
status.AnchorPoint = Vector2.new(0.5, 1)
status.Position = UDim2.new(0.5, 0, 1, -96)
status.Size = UDim2.fromOffset(480, 28)
status.BackgroundTransparency = 1
status.TextColor3 = Color3.new(1, 1, 1)
status.FontFace = BOLD
status.TextSize = 20
status.Text = ""
status.Parent = gui
gui.Parent = player:WaitForChild("PlayerGui")
local function powerLevel(): number
local level = player:GetAttribute("PowerLevel")
return if type(level) == "number" then level else 1
end
local function update()
coinsLabel.Text = `{short(coins.Value)} coins`
local level = powerLevel()
upgradeButton.Text = if level >= Config.MAX_POWER_LEVEL
then "Click Power maxed"
else `Upgrade: {short(Config.upgradeCost(level))}`
rebirthButton.Text = `Rebirth: {short(Config.rebirthCost(rebirths.Value))}`
end
coins.Changed:Connect(update)
rebirths.Changed:Connect(update)
player:GetAttributeChangedSignal("PowerLevel"):Connect(update)
update()
-- ה-"+N" שצץ מעל הכפתור. המספר הוא רק ניחוש בשביל המראה;
-- כמה הקליק שווה באמת, השרת מחליט.
local function popUp()
local pop = Instance.new("TextLabel")
pop.AnchorPoint = Vector2.new(0.5, 0.5)
pop.Position = UDim2.fromScale(0.5 + (math.random() - 0.5) * 0.1, 0.42)
pop.Size = UDim2.fromOffset(120, 40)
pop.BackgroundTransparency = 1
pop.TextColor3 = Color3.fromRGB(255, 214, 90)
pop.FontFace = BOLD
pop.TextScaled = true
pop.Text = `+{short(Config.clickValue(powerLevel(), rebirths.Value))}`
pop.Parent = gui
local tween = TweenService:Create(pop, TweenInfo.new(0.6), {
Position = pop.Position - UDim2.fromOffset(0, 60),
TextTransparency = 1,
})
tween.Completed:Once(function()
pop:Destroy()
end)
tween:Play()
end
clickButton.Activated:Connect(function()
clickEvent:FireServer()
popUp()
end)
local function ask(remote: RemoteFunction)
local ok, success, message = pcall(function()
return remote:InvokeServer()
end)
status.Text = if ok and type(message) == "string" then message else "No answer from the server. Try again."
status.TextColor3 = if ok and success == true then Color3.fromRGB(120, 220, 150) else Color3.new(1, 1, 1)
end
upgradeButton.Activated:Connect(function()
ask(buyUpgrade)
end)
rebirthButton.Activated:Connect(function()
ask(rebirthRemote)
end)
הכפתורים משתמשים ב-Activated, ש-Roblox מפעילה בלחיצה על הכפתור השמאלי של העכבר במחשב, בנגיעה בטלפון ובלחיצה על A (או איקס) בג׳ויפד במצב ניווט ב-UI.
בג׳ויפד A לוחץ רק על הכפתור שנבחר. כש-GuiService.AutoSelectGuiEnabled מופעל, הכפתור Select בג׳ויפד בוחר את הכפתורים שלכם במסך; משם שחקנים יכולים לעבור ביניהם וללחוץ על A. אם אתם רוצים שכפתור בג׳ויפד ילחץ מיד, קשרו אותו דרך ContextActionService והפעילו ממנו את אותו remote בשם Click.
ארבעה פרטים בסקריפט:
- כפתור ה-Click מותאם למסך. הגודל שלו הוא חלק מהמסך,
UIAspectRatioConstraintשומר אותו ריבועי, ו-UISizeConstraintמגביל אותו ל-200 על 200 פיקסלים. במסך מחשב הוא ברוחב 200 פיקסלים; בטלפון הוא מתכווץ ונכנס בין מונה המטבעות לכפתורים שלמטה. אם אתם מזיזים רכיבים, הרחיקו אותו מהם: ל-Rebirth אין אישור, כך שנגיעה בטעות יכולה לאפס את המטבעות והשדרוגים של השחקן. - ה-"+N" שצץ הוא רק בשביל המראה. הוא משתמש בעותק של הנוסחה בלקוח. אם השרת יתעלם מקליק בגלל מגבלת הקצב, ה-"+N" עדיין יופיע, אבל המטבעות לא ישתנו.
short()הופך מספרים גדולים לקריאים. 1,234 מוצג כ-1.2K, ו-5,600,000 כ-5.6M. הפונקציה מעגלת למטה, ולכן המונה אף פעם לא מציג יותר ממה שיש לכם. למספרים גדולים מ-T (טריליונים) הוסיפו רשומות ל-UNITS.- המסך מתעדכן לפי אירועים. הוא מאזין לערכים Coins ו-Rebirths ול-Attribute בשם PowerLevel, ולכן המחירים על הכפתורים נכונים, איך שהמספרים לא ישתנו.
ל-ScreenGui יש ResetOnSpawn שקבוע ל-false, ולכן הוא נשאר כשהדמות חוזרת לחיים. כאן זה חשוב: LocalScript ב-StarterPlayerScripts מועתק לשחקן פעם אחת, בכניסה, כך שהוא לא היה בונה את המסך מחדש.
שלב 4: שמרו התקדמות דרך PlayerData
בינתיים הכול מתאפס כשהשחקן יוצא. במקום סקריפט שמירה שני, הסימולטור מתחבר למודול PlayerData מהמדריך ל-DataStore. המודול הזה כבר מנסה שוב בקשות שנכשלו, שומר אוטומטית כל 180 שניות, שומר כשהשחקן יוצא וכשהשרת נכבה, ואף פעם לא שומר שחקן שהנתונים שלו לא נטענו.
- עברו את שלב 1 במדריך ל-DataStore, כדי להוסיף את ה-ModuleScript בשם
PlayerDataל-ServerScriptService. כדי לבדוק שמירה ב-Studio, הפעילו גישת Studio ל-API services בעותק בדיקה של המשחק, כמו שהפרק הראשון שלו מסביר. SimulatorService טוען את המודול בעצמו דרך require, כך שהסקריפטMainמהמדריך לא נחוץ כאן. - ב-PlayerData הוסיפו
PowerLevel = 1,ו-Rebirths = 0,לטבלהDEFAULTS, לידCoins = 0,. - באותו מודול הוסיפו
PowerLevel: number,ו-Rebirths: number,לטיפוסData, כדי שבדיקת הטיפוסים המחמירה תכיר את השדות החדשים. - ב-SimulatorService החליפו את
local SAVE_PROGRESS = falseב-local SAVE_PROGRESS = true.
שחקנים שנשמרו לפני שהוספתם את השדות מקבלים אותם אוטומטית: הפונקציה migrate ב-PlayerData ממלאת מ-DEFAULTS את כל השדות שחסרים בטבלה השמורה, ולכן הם מתחילים עם Click Power ברמה 1 ו-0 rebirths, ושומרים את ה-Coins שלהם. אם תדלגו על סעיף 2, SimulatorService ידפיס אזהרה עם השדות שצריך להוסיף, ולא יתחיל את השחקן.
למה הסימולטור כותב לטבלה של PlayerData
כשהשמירה מופעלת, SimulatorService לא מעתיק את המספרים לשום מקום. PlayerData.Get(player) מחזיר את הטבלה החיה שהמודול שומר, והסימולטור משנה את Coins, את PowerLevel ואת Rebirths באותה טבלה. לכל מספר יש עותק אחד, וסקריפט אחד כותב למאגר הנתונים. שני סקריפטים ששומרים את אותו מפתח דורסים זה את זה, ואחד מהם עלול לשמור מספרים ישנים מעל המספרים של השני.
אל תיצרו גם leaderstats ב-handler של Loaded, כמו שהמדריך ל-DataStore ממליץ למשחקים אחרים: SimulatorService כבר יוצר את Coins ואת Rebirths מהטבלה שנטענה. אם סקריפט של טבלת מובילים כבר יוצר leaderstats, מחקו אותו.
למה לא לשמור בכל קליק
Roblox מתירה לכל שרת 60 + 40 × שחקנים כתיבות למאגר נתונים רגיל בדקה (השאר נמצא בטבלת המגבלות של המדריך ל-DataStore). שמירה בכל קליק ב-15 קליקים בשנייה היא 900 כתיבות בדקה לשחקן אחד, הרבה יותר מ-100 שמקבל שרת עם שחקן אחד. שמירה של כל הטבלה כל 180 שניות, כשהשחקן יוצא וכשהשרת נכבה, עולה רק כמה כתיבות לשחקן, ובקריסה הולכת לאיבוד לכל היותר ההתקדמות מאז השמירה האוטומטית האחרונה.
אם הטעינה נכשלה, המודול נותן לשחקן לשחק על מספרים חדשים, אבל אף פעם לא שומר אותם, כך שטעינה גרועה לא יכולה לדרוס התקדמות אמיתית. המדריך מסביר איך המודול מטפל בזה.
למה השרת מחליט על כל מספר
אקספלויטרים שולטים במכשיר שלהם. במדריך האבטחה של Roblox כתוב שהם יכולים לשנות כל דבר בעותק המקומי שלהם של המשחק, ולהפעיל כל RemoteEvent או RemoteFunction כמה פעמים שירצו עם כל ארגומנט. הכלכלה של סימולטור מוגנת בדיוק כמו שסקריפט השרת שלו מוגן.
| אקספלויטר מנסה | אם הלקוח היה מחליט | מה SimulatorService עושה |
|---|---|---|
| להפעיל את Click בלולאה הכי מהר שאפשר | מטבעות בלי סוף | סופר לא יותר מ-15 קליקים בכל חלון של שנייה ומתעלם מהשאר. |
| לשלוח כמות מטבעות יחד עם הקליק | הוא בוחר לעצמו את הפרס | מתעלם מכל ארגומנט. שווי הקליק לקוח מהמספרים של השרת. |
| לקנות שדרוג או rebirth בלי המטבעות הנדרשים | שדרוגים בחינם | משווה את המחיר ל-Coins בשרת ועונה "You need N more coins." |
| לשנות את Coins ב-leaderstats במסך שלו | להוציא מטבעות שאין לו | אף פעם לא קורא את leaderstats. הוא רק כותב לשם מהטבלה שלו. |
| לקבוע את ה-Attribute בשם PowerLevel על ה-Player שלו | קליק חזק יותר | אף פעם לא קורא את ה-Attribute הזה, והשינוי נשאר במכשיר של השחקן. |
| להפעיל Rebirth פעמיים באותו רגע | שני rebirths במחיר של אחד | בודק מחדש את המחיר בכל קריאה, ובין הבדיקה לשינוי שום דבר לא מוותר על הביצוע. |
| לשנות את המחירים בעותק שלו של SimulatorConfig | שדרוגים זולים יותר | משתמש בעותק שלו של המודול. |
הכלל חל על כל remote בסימולטור: שלחו את מה שהשחקן רוצה לעשות, לא כמה זה עולה. במדריך ל-RemoteEvent בדיקת הארגומנטים של remotes מפורטת יותר.
ממה להימנע בסקריפטי קליקים מועתקים
| טריק | בעיה | המדריך הזה |
|---|---|---|
LocalScript מוסיף מטבעות דרך leaderstats.Coins.Value += 1 | השינוי נשאר במכשיר אחד, ובמכשיר שלו שולט האקספלויטר | השרת מוסיף מטבעות |
clickEvent:FireServer(amount) | הלקוח בוחר לעצמו את הפרס | Click לא מעביר ארגומנטים |
| אין מגבלת קצב בשרת | בתיעוד של Roblox כתוב אף פעם לא לסמוך רק על מגבלה בלקוח | לא יותר מ-15 קליקים בכל חלון של שנייה |
SetAsync בכל קליק או שדרוג | אוכל את מגבלת הכתיבות של השרת | PlayerData שומר כל 180 שניות, ביציאה ובכיבוי. שמרו מיד דרך PlayerData.SaveNow רק אחרי משהו שאסור לאבד, למשל קניות ב-Robux. |
| סקריפט מאגר נתונים שני רק בשביל הסימולטור | שני סקריפטים ששומרים את אותו מפתח דורסים זה את זה | כותב לטבלה של PlayerData |
לולאות while wait(1) do להכנסה פסיבית | Roblox מסמנת את wait הגלובלי כמיושן, ו-task.wait מחליף אותו | task.wait (ראו איך להרחיב) |
MouseButton1Click על כפתורים | מתואר ללחיצות עכבר | Activated, לעכבר, למגע ולג׳ויפד |
שלב 5: בדקו
עברו על סעיפים 1 עד 8 עם SAVE_PROGRESS = false ב-SimulatorService, כדי שכל בדיקת משחק תתחיל ממספרים חדשים. אם כבר הפעלתם שמירה בשלב 4, קבעו בינתיים false, ולסעיף 9 החזירו true.
- לחצו על Play. בראש המסך כתוב 0 coins, על הכפתור הירוק Upgrade: 10, ועל הכתום Rebirth: 1.0K.
- לחצו על הכפתור הסגול Click! עשר פעמים. כל קליק מציג 1+ זהוב, ו-Coins ברשימת השחקנים עולה ב-1.
- לחצו על Upgrade. המטבעות חוזרים ל-0, שורת הסטטוס נעשית ירוקה עם הטקסט "Click Power is now level 2.", ועל הכפתור כתוב עכשיו Upgrade: 15. מעכשיו כל קליק נותן 2 מטבעות.
- בלי ללחוץ, לחצו על Rebirth. שורת הסטטוס כותבת "You need 1000 more coins to rebirth.", ושום דבר לא משתנה.
- כדי לבדוק rebirth בלי 1,000 קליקים, עצרו את הבדיקה, שנו את
Coins = 0ל-Coins = 1000בשורה קרוב לסוף SimulatorService שמתחילה שחקנים חדשים, ולחצו על Play. לחצו על Rebirth: Coins הופך ל-0, Rebirths ברשימת השחקנים הופך ל-1, שורת הסטטוס כותבת "Rebirth 1! Every click is now worth x2.", ועל הכפתור כתוב עכשיו Rebirth: 3.0K. כל קליק נותן עכשיו 2 מטבעות ברמת Click Power 1. אחר כך החזירו את השורה ל-0. - כדי לראות את מגבלת הקצב, קבעו את
MAX_CLICKS_PER_SECONDב-SimulatorConfig ל-2 ולחצו מהר. ה-"+N" ממשיכים להופיע, אבל Coins עולה לכל היותר בשווי של 2 קליקים בשנייה. החזירו ל-15. - בחרו טלפון ב-Device Simulator ב-Studio (זו בטא של Studio; גם ה-Device Emulator הישן מתאים) ולחצו על Play. בדקו שכפתור ה-Click לא עולה לא על מונה המטבעות ולא על כפתורי Upgrade ו-Rebirth, ושורת הסטטוס בלחיצה על Upgrade גלויה ולא מוסתרת על ידי הכפתור.
- חברו ג׳ויפד או פתחו את Controller Emulator ב-Studio (Controller בלשונית Emulation) בזמן בדיקת משחק, לחצו על Select ובדקו שאפשר להגיע לשלושת הכפתורים וללחוץ עליהם דרך A.
- עם שמירה מופעלת (שלב 4) ושוב
SAVE_PROGRESS = true, הרוויחו קצת מטבעות, לחצו על Stop, ואז שוב על Play. ה-Coins, רמת ה-Click Power וה-Rebirths שלכם יחזרו.
צרו סימולטור חדר כושר או מכרה
הרבה סימולטורים מחליפים את הכפתור בפעולה בעולם: להרים משקולת, להניף מכוש, להניף חרב באוויר. מתחת זה אותו קליק. Tool יכול להפעיל את אותו remote בשם Click, ולכן SimulatorService, המחירים שלו ומגבלת הקצב שלו נשארים כמו שהם.
- ב-Explorer רחפו מעל StarterPack, הכניסו Tool וקראו לו
Dumbbell. הכניסו לתוכו Part בשםHandle, תנו לו צורה של משקולת והסירו את הסימון מ-Anchored, כמו בשלבים עם ה-Tool מהמדריך לחרב. - הכניסו ל-Tool LocalScript בשם
LiftClientוהדביקו את הקוד שלמטה. - לחצו על Play, קחו את המשקולת ולחצו. המטבעות עולים ב-Click Power שלכם על כל הרמה, בדיוק כמו עם הכפתור.
-- LocalScript בתוך ה-Tool בשם Dumbbell, בשם LiftClient.
-- כל הרמה היא קליק: היא מפעילה את אותו remote בשם Click כמו הכפתור, והשרת
-- מחליט כמה היא שווה וכמה הרמות לספור.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local tool = script.Parent :: Tool
local remotes = ReplicatedStorage:WaitForChild("SimulatorRemotes")
local clickEvent = remotes:WaitForChild("Click") :: RemoteEvent
local LIFT_SECONDS = 0.5 -- זמן בין הרמות במכשיר הזה; לשרת יש מגבלה משלו
local LIFT_ANIMATION_ID = "" -- לא חובה: "rbxassetid://" ואחריו ה-id של האנימציה שלכם
local player = Players.LocalPlayer
local lastLift = 0
local liftTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil
-- טוענים את אנימציית ההרמה פעם אחת לכל דמות, דרך ה-Animator ש-Roblox שמה ב-Humanoid
local function loadLift()
local character = player.Character
if LIFT_ANIMATION_ID == "" or not character or character == trackCharacter then
return
end
local humanoid = character:FindFirstChildOfClass("Humanoid")
local animator = humanoid and humanoid:FindFirstChildOfClass("Animator")
if animator then
local animation = Instance.new("Animation")
animation.AnimationId = LIFT_ANIMATION_ID
liftTrack = animator:LoadAnimation(animation)
trackCharacter = character
end
end
tool.Equipped:Connect(loadLift)
tool.Activated:Connect(function()
local now = os.clock()
if now - lastLift < LIFT_SECONDS then
return
end
lastLift = now
if liftTrack then
liftTrack:Play()
end
clickEvent:FireServer() -- בלי ארגומנטים: את הפרס מחשב השרת
end)
לאנימציית הרמה, צרו אותה ב-Animation Editor עם העדיפות Action, פרסמו אותה והדביקו את ה-ID שלה ב-LIFT_ANIMATION_ID. השלבים עם האנימציה מהמדריך לחרב עובדים באותה דרך.
- התאימו את מגבלת השרת לפעולה.
LIFT_SECONDSמאט רק שחקנים הגונים: רמאי יכול להפעיל את Click מהקוד שלו. אם הרמה היא הדרך היחידה להרוויח, הורידו אתMAX_CLICKS_PER_SECONDב-SimulatorConfig לקצב האמיתי, למשל ל-2 להרמה אחת כל 0.5 שנייה, כדי שסקריפט לא יוכל להרוויח יותר משחקן. אחר כך חשבו מחדש את טבלת הקצב: כל זמן בה מחושב ל-5 קליקים בשנייה. - השאירו או הסתירו את הכפתור. כפתור ה-Click ממשיך לעבוד ליד ה-Tool. כדי להסתיר אותו, הוסיפו
clickButton.Visible = falseמיד אחרי השורה ב-SimulatorClient שיוצרת אתclickButton. - הרווחה רק במקום הנכון. כדי לשלם רק בחדר הכושר או במכרה, בדקו בשרת איפה הדמות נמצאת לפני שסופרים קליק, למשל לפי המרחק ל-Part באזור הזה. בדיקה ב-LiftClient לא הייתה עוצרת אף אחד.
מה לעשות הלאה: סדר הבנייה של סימולטור
סימולטור הוא ערימה של מערכות מעל הלולאה הזו. בנו אותן בסדר הזה, כדי שלכל אחת יהיה מה להכפיל, ועשו בדיקת משחק אחרי כל אחת. זה הסדר שאנחנו ממליצים עליו, עם מדריך לכל שלב.
| סדר | מערכת | מדריך | למה דווקא עכשיו |
|---|---|---|---|
| 1 | הרווחה, שדרוג, rebirth | המדריך הזה | כל השאר מכפיל את הלולאה הזו, ולכן קודם כווננו את המספרים שלה לפי טבלת הקצב. |
| 2 | שמירה | המדריך ל-DataStore, ואז שלב 4 | התקדמות שמתאפסת בכניסה מחדש הורגת סימולטור. הוסיפו אותה לפני כל דבר ששחקנים יכולים לאבד. |
| 3 | ביצים וחיות מחמד כמכפילים | פתיחת ביצים וחיות מחמד שהולכות אחרי השחקן | מטרה שנייה לצד המטבעות: משהו שאפשר לאסוף ושהופך כל קליק ליקר יותר. |
| 4 | אזורים מאחורי rebirths | איך להרחיב | לאן ללכת אחרי rebirth, עם פרסים טובים יותר שהשרת בודק. |
| 5 | טבלאות מובילים | המדריך לטבלת מובילים | טופ 10 עולמי לפי rebirths נותן משמעות לטיפוס הארוך. |
| 6 | פרסים יומיים וקודים | פרסים יומיים וקודים | סיבות לחזור מחר ואחרי כל עדכון. |
| 7 | Game Passes | המדריך ל-Game Passes | 2x מטבעות, קליק אוטומטי או משבצת נוספת לחיית מחמד, עם בדיקה בשרת. מכרו אותם כשהלולאה החינמית כבר מעניינת. |
למסכים, ערכות ה-UI החינמיות ל-Roblox כוללות מסכים בסגנון סימולטורים יחד עם הסקריפטים שגורמים להם לעבוד.
איך ליצור סימולטור בלי לכתוב סקריפטים
סימולטור עדיין צריך סקריפטים: מישהו צריך להוסיף מטבעות, לבדוק מחירים ולשמור. לכתוב אותם בעצמכם לא חובה:
- ערכת סימולטור מה-Creator Store. קראו את הסקריפטים שלה לפני הפרסום, ובדקו שמטבעות משתנים רק ב-Script של שרת, ולא ב-LocalScript.
- פלאגין שמחולל סימולטורים. אותה בדיקה לכל מה שהוא יוצר.
- סוכן AI ב-Studio, למשל RoCode, שיכול לבנות את אותם שלושה סקריפטים בפלייס שפתוח אצלכם.
- Build באפליקציית Roblox לנייד. לפי התיעוד של Roblox, הוא יוצר מתיאור משחקי 2D ו-2.5D פשוטים יותר, למשל סימולטורי קליקים, ונפרס בהדרגה לפי אזורים.
מה שלא תבחרו, הריצו על התוצאה את הבדיקות משלב 5 ואת בדיקות האקספלויטים מהפרק למה השרת מחליט על כל מספר.
איך להרחיב: חיות מחמד, אזורים, קליק אוטומטי וטבלאות מובילים
חיות מחמד כמכפילים
גרסה נפוצה: כל חיית מחמד היא מכפיל. שמרו את רשימת ה-id של חיות המחמד של השחקן בטבלה השמורה שלו, ותנו לשרת להכפיל את clickValue בבונוס של כל חיה שמצוידת. פתחו ביצים בשרת: הלקוח מבקש לפתוח ביצה, השרת בודק ולוקח את המחיר, ואז בוחר חיה בהגרלה משוקללת. אף פעם אל תתנו ללקוח להגריל ביצה או להגיד איזו חיה יצאה. המדריך למלאי מראה איך מחזיקים, שומרים ומציגים פריטים של שחקן, וחיות מחמד עובדות באותה דרך. המדריך לפתיחת ביצים בונה את ההגרלה בשרת, והמדריך לחיות מחמד גורם להן לעוף ליד הבעלים.
אזורים שנפתחים ב-rebirths
אזור הוא חלק במפה עם פרסים טובים יותר מאחורי מחסום. נעלו את הפרס, ולא רק את הדלת: כל מה שמשלם בתוך האזור צריך לבדוק את ה-Rebirths של השחקן בטבלה של השרת לפני שהוא משלם. דלת ש-LocalScript פותח לשחקנים מתאימים טובה בשביל המראה, אבל אקספלויטרים יכולים לשנות Parts ולהזיז את הדמות שלהם במכשיר שלהם.
קליק אוטומטי כ-Game Pass
Autoclicker שנמכר כ-Game Pass צריך לרוץ בשרת. העבירו את הגוף של ה-handler של Click לפונקציה, למשל addClick(player), חברו אליה את ה-remote, ולבעלי ה-pass קראו לה מלולאה בשרת עם task.wait(0.5), ולא עם wait המיושן. אז קליקים אוטומטיים נכנסים לאותה מגבלה לשנייה כמו קליקים רגילים. בדקו בעלות בשרת דרך MarketplaceService:UserOwnsGamePassAsync, כמו שהמדריך ל-Game Passes עושה להטבות שלו. pass של 2x מטבעות עובד באותה דרך: הכפילו את clickValue בשרת לבעלים. לפני שקובעים מחיר, מחשבון המס על Robux החינמי יראה כמה כל מכירה מכניסה לכם אחרי החלק של Roblox, ומחשבון ה-DevEx יראה כמה ה-Robux האלה שווים בדולר אמריקאי.
טופ 10 עולמי לפי rebirths
leaderstats משווה רק שחקנים באותו שרת. כדי לדרג את ה-Rebirths של כל השחקנים, כתבו אותם למאגר נתונים ממוין (ordered data store) וקראו בחזרה את הרשומות העליונות, כמו בשלב 4 במדריך לטבלת מובילים. מאגרים ממוינים מתירים פחות כתיבות ממאגרים רגילים, 30 + 5 × שחקנים בדקה לשרת, ולכן כתבו כשהשחקן יוצא ולפי טיימר.
מספרים גדולים מאוד
מספרים ב-Luau הם double, והם שומרים בערך 15 ספרות משמעותיות. IntValue שומר מספרים שלמים עד בערך 9.2 קווינטיליון, אבל Roblox מזהירה שערכים גדולים מ-2^53 (בערך 9 קוודריליון) מאבדים דיוק בסקריפטים. עם ההגדרות האלה מחיר ה-rebirth עובר את הסף הזה ב-rebirth ה-29. אם המשחק שלכם הולך רחוק יותר, העבירו את ערכי ה-leaderstats ל-NumberValue (החליפו את IntValue בשני הסקריפטים), שמחזיק מספרים גדולים בהרבה עם אותו דיוק של בערך 15 ספרות, והוסיפו סיומות ל-short().
על מה משחק סימולטור נשען
סימולטור הוא משחק של מספרים. הקליק, השדרוג וה-rebirth שלמעלה הם כל הלולאה; אם שחקנים יישארו, תלוי באיך המספרים האלה גדלים. כל כמה דקות השחקן צריך להרשות לעצמו משהו שיאיץ את הדקות הבאות, וכל סשן צריך להיגמר ליד מטרה שבשבילה רוצים לחזור.
- צמיחה שמספיקה לאורך זמן. מחירי השדרוגים עולים מהר יותר מההכנסה, ולכן כל שלב לוקח קצת יותר זמן. rebirth מאפס את המטבעות בשביל מכפיל קבוע, והאזור הישן נעשה מהיר, והטיפוס מרגיש חדש.
- מה לאסוף. אזורים שצריך לפתוח, חיות מחמד מביצים שמכפילות את ההכנסה, וכלים לשדרוג נותנים לשחקנים רשימת מטרות מעבר למספר אחד.
- מספרים גדולים שנשארים קריאים. הציגו 1.5M, ולא 1500000, ושמרו מספרים כך שהשרת יוכל להשוות אותם גם כשהם נעשים גדולים.
מונטיזציה שמתאימה לסימולטור
passes נפוצים מכפילים מטבעות, נותנים משבצת נוספת לחיית מחמד, פותחים יותר ביצים בבת אחת או מפעילים קליק אוטומטי. מכרו אותם כ-Game Passes ובדקו בשרת. חבילות מטבעות הן developer products. אם ביצים או כל דבר עם תוצאה אקראית אפשר לקנות ב-Robux או במטבע שנקנה ב-Robux, Roblox דורשת להציג את הסיכויים לפני הקנייה: קראו את paid random items (באנגלית) לפני שאתם בונים חנות.
מה מחזיר שחקנים
התקדמות שמורה, אזור חדש או סט חיות מחמד בעדכונים, פרסים יומיים, קודים שמכריזים עליהם יחד עם עדכונים, וטבלת מובילים לפי rebirths. ז׳אנרים אחרים, כל אחד עם הלולאה, המערכות ותוכנית הבנייה שלו: ז׳אנרים של משחקים ב-Roblox.
שגיאות נפוצות ופתרונות
פתחו את חלון ה-Output (תפריט Window, ואז Output) לפני שלוחצים על Play. רוב הבעיות מדפיסות שם אזהרה או שגיאה עם שם הסקריפט והשורה.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("SimulatorRemotes")'
ה-LocalScript מחכה ל-remotes ש-SimulatorService יוצר כשהמשחק עולה. בדקו ש-SimulatorService הוא Script, לא LocalScript, שהוא נמצא ב-ServerScriptService ושאין ב-Output שגיאה ממנו. אותה אזהרה ל-SimulatorConfig אומרת שהמודול לא נמצא ב-ReplicatedStorage או שהוא נקרא אחרת.
הכפתורים לא מופיעים אף פעם
ה-LocalScript מחכה ל-leaderstats שלכם לפני שהוא בונה את המסך. אם ב-Output כתוב Infinite yield possible על leaderstats, SimulatorService עוד לא התחיל אתכם. עם SAVE_PROGRESS = true הוא מחכה ל-PlayerData, אז בדקו ש-PlayerData נמצא ב-ServerScriptService ונטען בלי שגיאות.
ב-Output כתוב "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"
השמירה מופעלת, אבל במודול PlayerData עוד אין את השדות החדשים. הוסיפו אותם ל-DEFAULTS שלו, כמו בשלב 4, ולחצו שוב על Play.
ה-"+1" צצים, אבל המטבעות לא עולים
השרת לא סופר את הקליקים. או שיש שגיאה ב-SimulatorService (חפשו ממנו טקסט אדום ב-Output), או שהקליקים מגיעים מהר יותר ממה ש-MAX_CLICKS_PER_SECOND מתיר. אם שחקנים נתקלים במגבלה במשחק רגיל, העלו אותה ב-SimulatorConfig.
שורת הסטטוס כותבת "No answer from the server. Try again."
הקריאה ל-BuyUpgrade או ל-Rebirth נפלה, ולא החזירה תשובה. הסיבה הרגילה היא שגיאה בתוך SimulatorService בזמן הטיפול בבקשה, אז חפשו ממנו שגיאה אדומה ב-Output: מצוינת בה השורה.
מונה המטבעות במסך ורשימת השחקנים מציגים מספרים שונים
עוד סקריפט גם יוצר תיקיית leaderstats, כך שלכל שחקן יש שתיים, וה-LocalScript עלול לקרוא את האחרת. מחקו את הסקריפט המיותר: SimulatorService יוצר בעצמו את Coins ואת Rebirths.
המטבעות מתאפסים בכל כניסה מחדש
השמירה כבויה. עברו על שלב 4. אם היא מופעלת, והמטבעות ב-Studio עדיין מתאפסים, בדקו שבעותק הבדיקה מופעלת גישת Studio ל-API services, כמו שהמדריך ל-DataStore מסביר.
לעשות עם RoCode
אם לא בא לכם להדביק את זה ביד, RoCode יכול לבנות את זה בפלייס שפתוח אצלכם. זה סוכן AI עצמאי לקוד, לא של Roblox: אתם מתארים את המערכת בצ׳אט שלו באתר, והפלאגין שלו ל-Roblox Studio יוצר סקריפטים ב-Explorer שלכם, כך שלא צריך להעתיק קוד מחלון הצ׳אט.
תעשה סימולטור קליקים: כפתור Click גדול שנותן מטבעות ששווים לרמת ה-Click Power שלי כפול (rebirths + 1), כפתור Upgrade שעולה 10 מטבעות ומתייקר פי 1.5 בכל רמה, וכפתור Rebirth ב-1,000 מטבעות שמאפס מטבעות ושדרוגים. תחזיק את המספרים בשרת ותגביל קליקים ל-15 בשנייה. כבר יש לי מודול PlayerData.
- יכול קודם לקרוא את המודול PlayerData שלכם וכל סקריפט leaderstats עם Search Scripts ו-Read Script, כדי להוסיף שדות לנתונים הקיימים שלכם, ולא לכתוב סקריפט שמירה שני
- יכול ליצור שלד של מסך דרך פריסת ה-HUD של Build UI (עם פלאגין 3.9 ומעלה, בסגנון סימולטור) או לבנות את הכפתורים ב-LocalScript, וכותב ModuleScript, Script של שרת ו-LocalScript עם Create Script
- הוא מונחה לבדוק את הקומפילציה של כל סקריפט שכתב עם Check Script, שמקמפל אותו ב-Studio בלי להריץ
- מציב נקודת ביטול לפני ואחרי כל קבוצת שינויים, ולכן Ctrl+Z מחזיר קבוצה אחת בכל פעם
RoCode לא יכול ליצור Game Passes ו-developer products או להעלות Meshes ואייקונים של חיות מחמד: את זה עושים ב-Creator Hub וב-Studio. עם פלאגין 3.9.11 ומעלה RoCode יכול להריץ בדיקת משחק של המשחק שלכם ב-Studio ולשלוט בדמות בדיקה כדי לבדוק שהכול עובד, ועם פלאגין 3.9.15 ומעלה דמות הבדיקה יכולה ללחוץ על כפתורים במסך, למשל ללחוץ על Click ולבדוק ש-Coins עלה. הוא מחליט בעצמו מתי להריץ בדיקת משחק, עד 2 לבנייה ועוד 1 לבדיקת התיקון שלו, ובודק רק את מה שבחר, אז את הלולאה בדקו בעצמכם. סימולטור שלם הוא כמה פרומפטים, מערכת אחת בכל פעם: איך בונים עם RoCode מערכת אחת לכל פרומפט. איך RoCode מתחבר ל-Studio.
שאלות נפוצות
איך יוצרים סימולטור ב-Roblox בלי סקריפטים?
סימולטור שעובד צריך סקריפטים: מישהו צריך להוסיף מטבעות, לבדוק מחירים ולשמור התקדמות. אפשר להדביק את שלושת הסקריפטים מהמדריך הזה כמו שהם ולשנות רק את המספרים ב-SimulatorConfig, או לתת לערכה מה-Creator Store, לפלאגין או לסוכן AI ליצור אותם ולבדוק שהשרת מחליט על המטבעות. אפשרויות.
איך מערכת rebirth עובדת?
rebirth מחליף את המטבעות והשדרוגים שלכם בבונוס קבוע. במדריך הזה ה-rebirth הראשון עולה 1,000 מטבעות; הוא קובע את Coins ל-0, את Click Power לרמה 1 ומוסיף 1 ל-Rebirths, ומשם כל קליק מוכפל ב-Rebirths + 1. כל rebirth עולה פי שלושה מהקודם.
איך יוצרים סימולטור כוח או חדר כושר?
תנו לשחקנים Tool, למשל משקולת, שה-LocalScript שלו מפעיל את אותו remote בשם Click ב-Tool.Activated. השרת מחשב את הפרס בדיוק כמו על לחיצה בכפתור. הורידו את מגבלת הקליקים בשרת לקצב ההרמות, כדי שסקריפט לא יוכל להרוויח יותר משחקן. הסקריפט נמצא בפרק הגרסה עם משקולת.
אילו מערכות צריך בסימולטור?
קודם לולאת ההרווחה, השדרוגים וה-rebirths, אחר כך שמירה, אחר כך חיות מחמד או אוסף אחר שמכפיל את ההכנסה, אזורים מאחורי rebirths, טבלאות מובילים, פרסים יומיים וקודים, ובסוף ממש Game Passes. בסדר הבנייה יש מדריך לכל אחת.
כמה זמן צריך לקחת rebirth?
מספיק זמן כדי ששחקנים יקנו קודם כמה שדרוגים, ומספיק קצר כדי להגיע לאחד כבר בסשן הראשון. עם המספרים של המדריך הזה, ה-rebirth הראשון מגיע בערך אחרי 1.2 דקות ב-5 קליקים בשנייה; אם מעלים את REBIRTH_BASE_COST ל-10,000, יהיו בערך 8 דקות. עוד הגדרות בטבלת הקצב.
איך מתגוננים מפני autoclickers?
השרת סופר לא יותר מ-15 קליקים לשחקן בכל חלון של שנייה ומתעלם מהשאר. מתחת למגבלה הזו סקריפט נראה בדיוק כמו שחקן מהיר, כך שאת הכלכלה מגנה דווקא המגבלה. אפשר גם למכור קליק אוטומטי כ-Game Pass שרץ בשרת.
למה מטבעות מתאפסים בכניסה מחדש?
בינתיים שום דבר לא שומר אותם. הוסיפו את המודול PlayerData מהמדריך ל-DataStore, הוסיפו PowerLevel ו-Rebirths ל-DEFAULTS שלו, וקבעו SAVE_PROGRESS = true ב-SimulatorService, כמו בשלב 4.
איך מוסיפים חיות מחמד לסימולטור?
הפכו כל חיית מחמד למכפיל שהשרת מחיל על קליקים. פתחו ביצים בשרת עם בחירה אקראית משוקללת, שמרו את ה-id של חיות המחמד של השחקן יחד עם שאר הנתונים שלו, והציגו אותן ב-GUI של מלאי, כמו במדריך למלאי.
מה עדיף: ללחוץ על Part או על כפתור?
שניהם מתאימים. כפתור במסך נוח בטלפונים, ו-Part עם ClickDetector מתאים למשחק שבו הכול קורה בעולם. לפי התיעוד של Roblox, השרת בכלל לא בודק אירועי ClickDetector, אז הגבילו את הקצב של הקליקים האלה בשרת באותה דרך.
מקורות וקריאה נוספת
- Roblox Creator Docs: Securing the client-server boundary (באנגלית). מגבלת קצב, דוגמה של חנות במשחק ואירועי ClickDetector
- Roblox Creator Docs: Security and cheat mitigation tactics (באנגלית). במה אקספלויטר שולט במכשיר שלו
- Roblox Creator Docs: Remote events and callbacks (באנגלית). FireServer, פרמטר השחקן, InvokeServer ו-OnServerInvoke
- Roblox Creator Docs: Leaderboards (באנגלית). leaderstats ומאגרי נתונים ממוינים
- Roblox Creator Docs: Data store error codes and limits (באנגלית). מגבלות כתיבה לשרת למאגרים רגילים וממוינים
- Roblox Engine API: GuiButton (באנגלית). Activated במחשב, בטלפון ובקונסולה
- Roblox Engine API: GuiService (באנגלית). AutoSelectGuiEnabled ובחירה של אובייקטי GUI בג׳ויפד
- Roblox Engine API: IntValue (באנגלית). טווח של 64 ביט ואובדן דיוק מעל 2^53
- Roblox Creator Docs: Size modifiers and constraints (באנגלית). UIAspectRatioConstraint ו-UISizeConstraint
- Roblox Creator Docs: Studio testing modes (באנגלית). Device Simulator ו-Controller Emulator
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.