מדריך · מערכות משחק

איך ליצור סימולטור ב-Roblox

כמעט כל הסימולטורים רצים על אותה לולאה: עושים משהו פשוט ומקבלים מטבע, מוציאים אותו על שדרוגים שמביאים אותו מהר יותר, ואז עושים rebirth כדי להתחיל מחדש עם מכפיל קבוע. במדריך הזה נבנה את הלולאה הזו כסימולטור קליקים משלושה סקריפטים, שבו כל מספר מחליט השרת, ונשמור את ההתקדמות עם המודול PlayerData מהמדריך ל-DataStore. אם עוד אף פעם לא יצרתם משחק ב-Studio, קודם צרו מסלול קצר עם מטבעות.

עודכן 20 בנובמבר 202620 דק׳ קריאהמאת:

בקצרה

סימולטור ב-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: הגרסה עם משקולת. אחר כך הוסיפו מערכות לפי סדר הבנייה שלמטה.
בעמוד הזה
  1. איך זה עובד
  2. 1. מודול ההגדרות
  3. 2. סקריפט השרת
  4. 3. כפתורים
  5. 4. שמירה
  6. למה השרת מחליט
  7. 5. בדיקה
  8. הגרסה עם משקולת
  9. סדר הבנייה
  10. בלי סקריפטים
  11. איך להרחיב
  12. הז׳אנר
  13. Common errors
  14. עם RoCode
  15. שאלות נפוצות
  16. מקורות וקריאה נוספת

איך לולאת הסימולטור העיקרית בנויה

איורהשחקן קונה Click Power ברמה 2 ב-10 מטבעות, ואז (מואץ) צובר 1,000 מטבעות ועושה rebirth: המטבעות והשדרוגים מתאפסים, וכל קליק שווה x2.

סימולטור הוא לולאה של שלוש פעולות. השחקן עושה שוב ושוב משהו פשוט כדי להרוויח מטבע, מוציא אותו על שדרוגים שמביאים אותו מהר יותר, וכשהשדרוגים נעשים יקרים, עושה rebirth: מוותר על המטבעות והשדרוגים בתמורה לבונוס שנשאר לתמיד, ושוב מטפס, הפעם מהר יותר. בסימולטורים אחרים במקום קליק מרימים משקולות, חופרים או אוספים פריטים, אבל הלולאה שמתחת זהה.

שלוש הפעולות בלולאה של המדריך הזה
פעולהכמה היא עולהמה היא נותנתמי מחליט
קליקכלוםמטבעות ששווים Click Power × (Rebirths + 1)השרת, שסופר לא יותר מ-15 קליקים בכל חלון באורך שנייה
שדרוג10 מטבעות, ואז פי 1.5 מהמחיר הקודם לכל רמהעוד רמה אחת של Click Power, עד ה-50השרת, לפי העותק שלו של המחירים
Rebirth1,000 מטבעות, ואז פי 3 מהמחיר הקודם לכל rebirthהמטבעות חוזרים ל-0 ו-Click Power חוזר לרמה 1, ועוד 1+ קבוע למכפילהשרת

כל מספר חי בשרת. המכשיר של השחקן מצייר כפתורים ומבקש ("לחצתי", "אני רוצה שדרוג"), והשרת מחליט כמה זה עולה ואם אפשר לעשות את זה. סקריפטי קליקים שנפרצים מוסיפים לעיתים קרובות מטבעות ב-LocalScript, או נותנים ללקוח לשלוח כמה מטבעות להוסיף.

ממה מורכב הסימולטור
רכיבאיפה הוא נמצאמה הוא עושה
ModuleScript SimulatorConfigReplicatedStorageמחירים, מגבלות ונוסחאות לשווי קליק, מחיר שדרוג ומחיר rebirth. שני הצדדים קוראים אותו.
Script SimulatorServiceServerScriptServiceמחזיק את המספרים של כל שחקן, מטפל בקליקים, בשדרוגים וב-rebirths וממלא את leaderstats.
Folder SimulatorRemotesReplicatedStorage (נוצר על ידי SimulatorService)RemoteEvent בשם Click ו-RemoteFunctions בשם BuyUpgrade ו-Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsבונה כפתורים, שולח קליקים ובקשות ומציג את המספרים של השרת.
ModuleScript בשם PlayerData (לא חובה)ServerScriptServiceשומר התקדמות בין כניסות. הוא לקוח מהמדריך ל-DataStore ונחוץ רק לשלב 4.
ה-Explorer בזמן המשחק. SimulatorService יוצר את SimulatorRemotes ואת שלושת ה-remotes כשהמשחק עולה, ו-PlayerData מופיע רק אחרי שתוסיפו שמירה בשלב 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 לוקח ממנו מחירים לכפתורים, ולכן כל שינוי הוא עריכה אחת במקום אחד.

  1. ב-Explorer רחפו מעל ReplicatedStorage, לחצו על כפתור ה-+ והכניסו ModuleScript.
  2. שנו את השם שלו ל-SimulatorConfig (השמות רגישים לאותיות גדולות וקטנות) והחליפו את התוכן שלו בקוד שלמטה.
ModuleScript בתוך ReplicatedStorage בשם 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 אחד
11012
21524
32236
43348
550510

rebirths עולים 1,000 מטבעות, אחר כך 3,000, אחר כך 9,000, כי rebirthCost מכפיל כל פעם את המחיר ב-3. אחרי rebirth אחד כל קליק שווה כפול, אחרי שניים פי שלושה, וכן הלאה.

כמה זמן לוקח rebirth עם המספרים האלה

הנוסחאות קובעות כמה זמן הלולאה נמשכת, ולכן כדאי לחשב את המספרים לפני שהשחקנים יעשו את זה. הטבלה מניחה שהשחקן עושה rebirth ברגע שהוא יכול לשלם עליו, ובשאר הזמן קונה את הרמה הבאה של Click Power כשהוא יכול לשלם עליה והיא עולה פחות מ-rebirth. הזמן נספר מהתחלה חדשה, ולכן העמודה האחרונה היא הזמן הכולל עד 3 rebirths.

דקות מהתחלה חדשה עד כל rebirth ב-5 קליקים בשנייה, לפי REBIRTH_BASE_COST. חושב לפי הנוסחאות של SimulatorConfig, לא נמדד על שחקנים
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1,000 (המדריך הזה)1.22.74.8
5 0004.310.118.3
10 0008.216.933.2
25 00016.740.174.5
50 00032.868.8137.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 והחליפו את התוכן בקוד הזה:

Script בתוך ServerScriptService בשם 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 למטה ושורת סטטוס לתשובות של השרת. הוא עצמו אף פעם לא משנה אף מספר.

  1. ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts והכניסו LocalScript בשם SimulatorClient.
  2. החליפו את התוכן שלו בקוד שלמטה ולחצו על Play.
LocalScript בתוך StarterPlayerScripts בשם SimulatorClient
-- בונה את כפתורי הסימולטור ומציג את המספרים של השרת. הוא עצמו אף פעם לא משנה אותם.

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. עברו את שלב 1 במדריך ל-DataStore, כדי להוסיף את ה-ModuleScript בשם PlayerData ל-ServerScriptService. כדי לבדוק שמירה ב-Studio, הפעילו גישת Studio ל-API services בעותק בדיקה של המשחק, כמו שהפרק הראשון שלו מסביר. SimulatorService טוען את המודול בעצמו דרך require, כך שהסקריפט Main מהמדריך לא נחוץ כאן.
  2. ב-PlayerData הוסיפו PowerLevel = 1, ו-Rebirths = 0, לטבלה DEFAULTS, ליד Coins = 0,.
  3. באותו מודול הוסיפו PowerLevel: number, ו-Rebirths: number, לטיפוס Data, כדי שבדיקת הטיפוסים המחמירה תכיר את השדות החדשים.
  4. ב-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 עושה
אקספלויטר מנסהאם הלקוח היה מחליטמה 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.

  1. לחצו על Play. בראש המסך כתוב 0 coins, על הכפתור הירוק Upgrade: 10, ועל הכתום Rebirth: 1.0K.
  2. לחצו על הכפתור הסגול Click! עשר פעמים. כל קליק מציג 1+ זהוב, ו-Coins ברשימת השחקנים עולה ב-1.
  3. לחצו על Upgrade. המטבעות חוזרים ל-0, שורת הסטטוס נעשית ירוקה עם הטקסט "Click Power is now level 2.", ועל הכפתור כתוב עכשיו Upgrade: 15. מעכשיו כל קליק נותן 2 מטבעות.
  4. בלי ללחוץ, לחצו על Rebirth. שורת הסטטוס כותבת "You need 1000 more coins to rebirth.", ושום דבר לא משתנה.
  5. כדי לבדוק 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.
  6. כדי לראות את מגבלת הקצב, קבעו את MAX_CLICKS_PER_SECOND ב-SimulatorConfig ל-2 ולחצו מהר. ה-"+N" ממשיכים להופיע, אבל Coins עולה לכל היותר בשווי של 2 קליקים בשנייה. החזירו ל-15.
  7. בחרו טלפון ב-Device Simulator ב-Studio (זו בטא של Studio; גם ה-Device Emulator הישן מתאים) ולחצו על Play. בדקו שכפתור ה-Click לא עולה לא על מונה המטבעות ולא על כפתורי Upgrade ו-Rebirth, ושורת הסטטוס בלחיצה על Upgrade גלויה ולא מוסתרת על ידי הכפתור.
  8. חברו ג׳ויפד או פתחו את Controller Emulator ב-Studio (Controller בלשונית Emulation) בזמן בדיקת משחק, לחצו על Select ובדקו שאפשר להגיע לשלושת הכפתורים וללחוץ עליהם דרך A.
  9. עם שמירה מופעלת (שלב 4) ושוב SAVE_PROGRESS = true, הרוויחו קצת מטבעות, לחצו על Stop, ואז שוב על Play. ה-Coins, רמת ה-Click Power וה-Rebirths שלכם יחזרו.

צרו סימולטור חדר כושר או מכרה

הרבה סימולטורים מחליפים את הכפתור בפעולה בעולם: להרים משקולת, להניף מכוש, להניף חרב באוויר. מתחת זה אותו קליק. Tool יכול להפעיל את אותו remote בשם Click, ולכן SimulatorService, המחירים שלו ומגבלת הקצב שלו נשארים כמו שהם.

  1. ב-Explorer רחפו מעל StarterPack, הכניסו Tool וקראו לו Dumbbell. הכניסו לתוכו Part בשם Handle, תנו לו צורה של משקולת והסירו את הסימון מ-Anchored, כמו בשלבים עם ה-Tool מהמדריך לחרב.
  2. הכניסו ל-Tool LocalScript בשם LiftClient והדביקו את הקוד שלמטה.
  3. לחצו על Play, קחו את המשקולת ולחצו. המטבעות עולים ב-Click Power שלכם על כל הרמה, בדיוק כמו עם הכפתור.
LocalScript בתוך ה-Tool בשם Dumbbell ב-StarterPack בשם LiftClient
-- 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 לא הייתה עוצרת אף אחד.

מה לעשות הלאה: סדר הבנייה של סימולטור

סימולטור הוא ערימה של מערכות מעל הלולאה הזו. בנו אותן בסדר הזה, כדי שלכל אחת יהיה מה להכפיל, ועשו בדיקת משחק אחרי כל אחת. זה הסדר שאנחנו ממליצים עליו, עם מדריך לכל שלב.

סדר הבנייה של סימולטור ב-Roblox, מהלולאה העיקרית החוצה
סדרמערכתמדריךלמה דווקא עכשיו
1הרווחה, שדרוג, rebirthהמדריך הזהכל השאר מכפיל את הלולאה הזו, ולכן קודם כווננו את המספרים שלה לפי טבלת הקצב.
2שמירההמדריך ל-DataStore, ואז שלב 4התקדמות שמתאפסת בכניסה מחדש הורגת סימולטור. הוסיפו אותה לפני כל דבר ששחקנים יכולים לאבד.
3ביצים וחיות מחמד כמכפיליםפתיחת ביצים וחיות מחמד שהולכות אחרי השחקןמטרה שנייה לצד המטבעות: משהו שאפשר לאסוף ושהופך כל קליק ליקר יותר.
4אזורים מאחורי rebirthsאיך להרחיבלאן ללכת אחרי rebirth, עם פרסים טובים יותר שהשרת בודק.
5טבלאות מוביליםהמדריך לטבלת מוביליםטופ 10 עולמי לפי rebirths נותן משמעות לטיפוס הארוך.
6פרסים יומיים וקודיםפרסים יומיים וקודיםסיבות לחזור מחר ואחרי כל עדכון.
7Game Passesהמדריך ל-Game Passes2x מטבעות, קליק אוטומטי או משבצת נוספת לחיית מחמד, עם בדיקה בשרת. מכרו אותם כשהלולאה החינמית כבר מעניינת.

למסכים, ערכות ה-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.

RoCode עושה
  • יכול קודם לקרוא את המודול 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, אז הגבילו את הקצב של הקליקים האלה בשרת באותה דרך.

מקורות וקריאה נוספת

איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.

נסו את RoCode במשחק שלכם.

קרדיטים חינמיים בכל יום, בלי כרטיס אשראי. התקינו את הפלאגין, תארו פיצ'ר ובדקו מה מופיע ב-Studio.