Ръководство · Системи в играта

Как да направиш симулатор в Roblox

Почти всички симулатори се въртят около един цикъл: правиш нещо просто и получаваш валута, харчиш я за ъпгрейди, които я носят по-бързо, а после правиш ребърт (прераждане), за да започнеш отначало с постоянен множител. В това ръководство изграждаме този цикъл като кликер от три скрипта, в който всяко число решава сървърът, и запазваме напредъка с модула PlayerData от ръководството за DataStore. Ако никога не си правил игра в Studio, първо направи кратко трасе с монети.

Обновено 20 ноември 2026 г.25 мин четенеАвтор:

Накратко

Симулаторът в Roblox е един цикъл: кликай, за да получаваш монети, харчи ги за ъпгрейди, които дават повече, а после прави ребърт заради постоянен множител. Пази цените в ModuleScript в ReplicatedStorage. Един Script в ServerScriptService пази за всеки играч Coins, Click Power и Rebirths, отчита не повече от 15 клика в секунда от RemoteEvent Click и продава ъпгрейди и ребърти чрез RemoteFunction след проверка на цената. LocalScript показва бутоните Click, Upgrade и Rebirth. С числата от това ръководство играч, който кликва 5 пъти в секунда, стига до първия ребърт за около 1.2 минути, а таблицата за темпото показва какво да промениш, за да е изкачването по-дълго.

  • Кликът не носи нищо освен самия клик. Колко струва, смята сървърът, затова промененият клиент не може да си начисли монети.
  • Запазвай цялата таблица по таймер и при излизане на играча, а не при всеки клик. Roblox позволява на всеки сървър 60 + 40 × играчи записа в хранилището за данни на минута.
  • Не можеш да пишеш скриптове? Същия цикъл може да го сглоби пакет от Creator Store, плъгин или ИИ агент. Провери дали монетите ги решава сървърът: варианти.
  • Трябва ти фитнес или мина вместо бутон? Tool може да вика същия ремоут 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 монети и прави ребърт: монетите и ъпгрейдите се нулират, а всеки клик струва x2.

Симулаторът е цикъл от три действия. Играчът отново и отново прави нещо просто, за да спечели валута, харчи я за ъпгрейди, които я носят по-бързо, а когато ъпгрейдите станат скъпи, прави ребърт: дава монетите и ъпгрейдите срещу бонус, който остава завинаги, и отново се изкачва, вече по-бързо. В други симулатори вместо клик вдигат гири, копаят или събират предмети, но цикълът отдолу е същият.

Трите действия в цикъла на това ръководство
ДействиеКолко струваКакво даваКой решава
КликНищоМонети, равни на Click Power × (Rebirths + 1)Сървърът, който отчита не повече от 15 клика във всеки прозорец с дължина една секунда
Ъпгрейд10 монети, после 1.5 пъти повече от предишната цена за всяко нивоОще едно ниво на Click Power, до 50-оСървърът, по своето копие на цените
Ребърт1 000 монети, после 3 пъти повече от предишната цена за всеки ребъртМонетите обратно на 0 и Click Power обратно на ниво 1, плюс постоянен +1 към множителяСървърът

Всяко число живее на сървъра. Устройството на играча рисува бутоните и моли ("кликнах", "искам ъпгрейд"), а сървърът решава колко струва това и дали може да се направи. Скриптовете за кликери, които биват чупени, често добавят монети в LocalScript или позволяват на клиента да изпрати колко монети да се добавят.

От какво се състои симулаторът
ЕлементКъде се намираКакво прави
ModuleScript SimulatorConfigReplicatedStorageЦени, лимити и формули за стойността на клика, цената на ъпгрейда и цената на ребърта. Четат го и двете страни.
Script SimulatorServiceServerScriptServiceПази числата на всеки играч, обработва кликовете, ъпгрейдите и ребъртите и попълва leaderstats.
Folder SimulatorRemotesReplicatedStorage (създава го SimulatorService)RemoteEvent Click и RemoteFunction BuyUpgrade и Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsСтрои бутоните, изпраща кликовете и заявките и показва числата на сървъра.
ModuleScript PlayerData (незадължително)ServerScriptServiceЗапазва напредъка между влизанията. Взет е от ръководството за DataStore и е нужен само за стъпка 4.
Explorer по време на игра. SimulatorService създава SimulatorRemotes и трите ремоута при пускането на играта, а 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: колко струва кликът, колко струва всеки ъпгрейд и ребърт и лимитът на кликовете. Сървърът решава по него, а 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 -- монети за първия ребърт
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- всеки ребърт струва 3 пъти повече от предишния
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- кликовете над това за една секунда се пренебрегват

-- Монети за един клик: нивото на Click Power, умножено по 1 + броя ребърти
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

-- Монети, нужни за следващия ребърт
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

Играчите могат да прочетат ModuleScript в ReplicatedStorage, така че тези цени са публични. Това е нормално: те и без това са написани на бутоните. Клиентът и сървърът пускат всеки свое копие на модула, затова играч, който промени числата на своето устройство, няма да промени нищо на сървъра.

Какво дават формулите с тези настройки
Ниво на Click PowerЦена на следващото нивоМонети на клик, без ребъртиМонети на клик, 1 ребърт
11012
21524
32236
43348
550510

Ребъртите струват 1 000 монети, после 3 000, после 9 000, защото rebirthCost всеки път умножава цената по 3. След един ребърт всеки клик струва два пъти повече, след два три пъти повече и така нататък.

Колко трае един ребърт с тези числа

Формулите решават колко трае цикълът, затова си струва да сметнеш числата, преди да го направят играчите. Таблицата приема, че играчът прави ребърт веднага щом може да го плати, а през останалото време купува следващото ниво на Click Power, когато може да го плати и то струва по-малко от ребърта. Времето се брои от нов старт, затова последната колона е общото време до 3 ребърта.

Минути от нов старт до всеки ребърт при 5 клика в секунда, според REBIRTH_BASE_COST. Пресметнато по формулите на SimulatorConfig, а не измерено с играчи
REBIRTH_BASE_COSTРебърт 1Ребърт 2Ребърт 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

Без ребърти ниво 5 на Click Power идва след 34 клика, ниво 10 след 122, а ниво 13 след 285. С числата по подразбиране играчът след това спира да вдига нивото, защото ниво 14 струва 1 297 монети, повече от ребърт за 1 000 монети, и първият ребърт идва след общо 362 клика. При сървърен лимит от 15 клика в секунда раздели всяко време на 3. Промениш ли което и да е число в SimulatorConfig, тези времена ще се променят заедно с него, така че ги пресметни отново.

Настройка на растежа

Двете числа _GROWTH задават колко бързо растат цените. При 1.5 всеки ъпгрейд струва един път и половина повече от предишния, а всяко ниво добавя само една монета на клик (преди множителя на ребъртите), така че всяко ново ниво се изплаща все по-бавно. Точно това забавяне прави ребърта изгоден. Вдигни растежа за по-дълго изкачване, свали го за по-бързо и дръж REBIRTH_BASE_COST достатъчно висок, за да купят играчите няколко ъпгрейда преди първия ребърт.

За да е първият ребърт след няколко минути, а не след около една, вдигни REBIRTH_BASE_COST на 5 000 или 10 000.

Стъпка 2: добави сървърния скрипт

Този Script притежава всяко число. Създава ремоутите, дава на всеки играч папка leaderstats с Coins и Rebirths и отговаря на три заявки. Задръж курсора над ServerScriptService, вмъкни Script, преименувай го на SimulatorService и замени съдържанието му с този код:

Script в ServerScriptService с име SimulatorService
-- Притежава всяко число: кликовете носят монети тук, ъпгрейдите и ребъртите се купуват тук,
-- а 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 и един атрибут
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 -- автокликер или скрипт, който вика ремоута в цикъл
	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
	-- Ребъртът сменя монетите и ъпгрейдите срещу постоянен множител
	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 стига до играча като атрибут PowerLevel на неговия обект Player, а не като трета стойност в leaderstats, затова списъкът с играчи показва само Coins и Rebirths. Атрибутите, които слага сървърът, се репликират на устройството на играча; промяна, която играчът направи на своето устройство, си остава там.

Кликове и лимит на честотата

Ремоутът Click не подава аргументи. На сървъра първият параметър на обработчика OnServerEvent винаги е играчът, който го е извикал, затова сървърът знае кой е кликнал, взима неговото ниво на Click Power и Rebirths и добавя clickValue към неговите Coins. В заявката няма нищо, което чийтър би могъл да промени.

В ръководството на Roblox за сигурност пише никога да не разчиташ само на лимит на честотата на клиента, а начисляването на валута там е сред действията, които трябва да се ограничават. Сървърът брои кликовете на всеки играч в прозорци от по една секунда: първият клик отваря прозореца, а когато са отчетени 15 клика, останалите се пренебрегват, докато не мине секунда от началото на прозореца. Скрипт, който вика ремоута в цикъл, получава не повече от 15 отчетени клика във всеки прозорец. За да позволиш по-бързо или по-бавно кликане, промени MAX_CLICKS_PER_SECOND в SimulatorConfig.

Ъпгрейди и ребърти

BuyUpgrade и Rebirth са RemoteFunction, затова бутонът може да изчака отговора и да го покаже. Всеки обработчик взима цената от сървърното копие на SimulatorConfig, проверява Coins на играча и едва след това променя нещо. Връща true или false и съобщение, например "You need 5 more coins.", което LocalScript показва в реда за статус.

Между проверката на цената и промяната нищо не чака и не отстъпва изпълнението (yield), затова две заявки от един играч не могат и двете да минат проверката, преди първата да е взела монетите. Ребъртът слага Coins на 0, Click Power на ниво 1 и добавя 1 към Rebirths, а формулата на клика превръща това в множител Rebirths + 1.

Превключвателят SAVE_PROGRESS

При SAVE_PROGRESS = false всеки играч при всяко влизане започва с 0 монети и точно това ти трябва, докато сглобяваш играта. Стъпка 4 го включва. Тогава скриптът чака модулът PlayerData да зареди всеки играч и работи направо с таблицата, която този модул запазва, така че всяка монета и всеки ребърт се запазват без допълнителен код.

Стъпка 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 и викай от него същия ремоут Click.

Четири детайла в скрипта:

  • Бутонът Click се мащабира според екрана. Размерът му е част от екрана, UIAspectRatioConstraint го държи квадратен, а UISizeConstraint го ограничава до 200 на 200 пиксела. На монитор е широк 200 пиксела; на телефон се смалява и се побира между брояча на монети и бутоните долу. Ако местиш елементите, дръж го далеч от тях: Rebirth няма потвърждение, така че случайно докосване може да нулира монетите и ъпгрейдите на играча.
  • Изскачащото "+N" е само за вида. То използва клиентското копие на формулата. Ако сървърът пренебрегне клика заради лимита на честотата, "+N" пак ще се появи, но монетите няма да се променят.
  • short() прави големите числа четливи. 1 234 се показва като 1.2K, а 5 600 000 като 5.6M. Функцията закръгля надолу, затова броячът никога не показва повече, отколкото имаш. За числа над T (трилиони) добави записи в UNITS.
  • Екранът се обновява по събития. Слуша стойностите Coins и Rebirths и атрибута PowerLevel, затова цените на бутоните са верни, както и да се променят числата.

На ScreenGui ResetOnSpawn е false, затова той остава, когато персонажът се появи отново. Тук това е важно: LocalScript в StarterPlayerScripts се копира на играча веднъж, при влизане, така че не би построил екрана наново.

Стъпка 4: запазвай напредъка чрез PlayerData

Засега всичко се нулира, когато играчът излезе. Вместо втори скрипт за запазване симулаторът се свързва с модула PlayerData от ръководството за DataStore. Този модул вече повтаря неуспешните заявки, автоматично запазва на всеки 180 секунди, запазва при излизане на играча и при спиране на сървъра и никога не запазва играч, чиито данни не са се заредили.

  1. Мини стъпка 1 от ръководството за DataStore, за да добавиш ModuleScript PlayerData в ServerScriptService. За да провериш запазването в Studio, включи достъпа на Studio до API услугите в тестово копие на играта, както обяснява първият му раздел. 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 ребърта и запазват своите Coins. Ако пропуснеш точка 2, SimulatorService ще изведе предупреждение с полетата, които трябва да добавиш, и няма да стартира играча.

Защо симулаторът пише в таблицата на PlayerData

Когато запазването е включено, SimulatorService не копира числата никъде. PlayerData.Get(player) връща живата таблица, която модулът запазва, и симулаторът променя Coins, PowerLevel и Rebirths в същата таблица. Всяко число има едно копие и в хранилището за данни пише един скрипт. Два скрипта, които запазват един и същ ключ, се презаписват един друг и единият може да запише стари числа върху числата на другия.

Не прави и leaderstats в обработчика Loaded, както ръководството за DataStore съветва за други игри: SimulatorService вече прави Coins и Rebirths от заредената таблица. Ако leaderstats вече ги прави скрипт за класация, изтрий го.

Защо да не запазваш при всеки клик

Roblox позволява на всеки сървър 60 + 40 × играчи записа в обикновено хранилище за данни на минута (останалото е в таблицата с лимити в ръководството за DataStore). Запазване при всеки клик при 15 клика в секунда са 900 записа на минута за един играч, много повече от онези 100, които получава сървър с един играч. Запазването на цялата таблица на всеки 180 секунди, при излизане на играча и при спиране на сървъра струва само няколко записа на играч, а при срив се губи най-много напредъкът от последното автоматично запазване.

Ако зареждането не успее, модулът позволява на играча да играе с нови числа, но никога не ги запазва, така че лошо зареждане не може да изтрие истинския напредък. Ръководството обяснява как модулът се справя с това.

Защо всяко число решава сървърът

Експлойтърите управляват своето устройство. В ръководството на Roblox за сигурност пише, че могат да променят каквото си искат в своето локално копие на играта и да викат всеки RemoteEvent или RemoteFunction колкото пъти искат с каквито и да е аргументи. Икономиката на симулатора е защитена точно толкова, колкото е защитен сървърният му скрипт.

Какво може да опита експлойтър и какво прави SimulatorService
Експлойтърът опитваАко решаваше клиентътКакво прави SimulatorService
Да вика Click в цикъл колкото се може по-бързоБезкрайни монетиОтчита не повече от 15 клика във всеки секунден прозорец и пренебрегва останалите.
Да изпрати брой монети заедно с кликаСам си избира наградатаПренебрегва всякакви аргументи. Стойността на клика се взима от числата на сървъра.
Да купи ъпгрейд или ребърт без нужните монетиБезплатни ъпгрейдиСверява цената с Coins на сървъра и отговаря "You need N more coins."
Да промени Coins в leaderstats на своя екранДа харчи монети, които нямаНикога не чете leaderstats. Само пише там от своята таблица.
Да сложи атрибута PowerLevel на своя PlayerПо-силен кликНикога не чете този атрибут, а промяната остава на устройството на играча.
Да извика Rebirth два пъти в един моментДва ребърта на цената на единПроверява цената наново при всяко извикване и между проверката и промяната нищо не отстъпва изпълнението.
Да промени цените в своето копие на SimulatorConfigПо-евтини ъпгрейдиИзползва своето копие на модула.

Правилото важи за всеки ремоут в симулатора: изпращай това, което играчът иска да направи, а не колко струва то. В ръководството за RemoteEvent проверката на аргументите на ремоутите е разгледана по-подробно.

Какво да избягваш в копирани скриптове за кликери

Чести похвати от стари ръководства за кликери и какво прави това ръководство вместо тях
ПохватПроблемТова ръководство
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.waittask.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. За да тестваш ребърта без 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 може да вика същия ремоут 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.
-- Всяко вдигане е клик: вика същия ремоут 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.
  • Печалба само на правилното място. За да се плаща само във фитнеса или в мината, проверявай на сървъра къде се намира персонажът, преди да отчетеш клика, например по разстоянието до парт в тази зона. Проверка в LiftClient не би спряла никого.

Какво следва: ред на изграждане на симулатора

Симулаторът е купчина системи върху този цикъл. Изграждай ги в този ред, за да има всяка какво да умножава, и прави плейтест след всяка. Ето реда, който съветваме, с ръководство за всяка стъпка.

Ред на изграждане на симулатор в Roblox, от основния цикъл навън
РедСистемаРъководствоЗащо точно сега
1Печалба, ъпгрейд, ребъртТова ръководствоВсичко останало умножава този цикъл, затова първо настрой числата му по таблицата за темпото.
2ЗапазванеРъководството за DataStore, после стъпка 4Напредък, който се нулира при повторно влизане, убива симулатора. Добави го преди всичко, което играчите могат да загубят.
3Яйца и петове като множителиИзлюпване на яйца и петове, които следват играчаВтора цел до монетите: нещо, което може да се събира и което прави всеки клик по-ценен.
4Зони зад ребъртиКак да разширишКъде да отидеш след ребърт, с по-добри награди, които проверява сървърът.
5КласацииРъководството за класацияГлобален топ 10 по ребърти придава смисъл на дългото изкачване.
6Дневни награди и кодовеДневни награди и кодовеПоводи да се върнеш утре и след всяко обновление.
7ГеймпасовеРъководството за геймпасове2x монети, автоклик или допълнителен слот за пет, с проверка на сървъра. Продавай ги, когато безплатният цикъл вече е интересен.

За екраните безплатните UI пакети за Roblox включват екрани в стил симулатор заедно със скриптовете, които ги карат да работят.

Как да направиш симулатор, без да пишеш скриптове

На симулатора пак му трябват скриптове: някой трябва да добавя монети, да проверява цените и да запазва. Не е задължително да ги пишеш сам:

  • Пакет за симулатор от Creator Store. Прочети скриптовете му преди публикуване и провери дали монетите се променят само в сървърен Script, а не в LocalScript.
  • Плъгин генератор на симулатори. Същата проверка за всичко, което създава.
  • ИИ агент в Studio, например RoCode, който може да сглоби същите три скрипта в плейса, който имаш отворен.
  • Build в мобилното приложение на Roblox. Според документацията на Roblox прави по описание по-прости 2D и 2.5D игри, например кликери, и излиза постепенно по региони.

Каквото и да избереш, пусни върху резултата проверките от стъпка 5 и проверките за експлойти от раздела Защо всяко число решава сървърът.

Как да разшириш: петове, зони, автоклик и класации

Петове като множители

Чест вариант: всеки пет е множител. Пази списъка с id на петовете на играча в неговата запазена таблица, а сървърът нека умножава clickValue по бонуса на всеки екипиран пет. Отваряй яйцата на сървъра: клиентът моли да отвори яйце, сървърът проверява и взима цената, а после избира пет с претеглено случайно хвърляне. Никога не позволявай на клиента да хвърля за яйцето или да казва кой пет се е паднал. Ръководството за инвентар показва как да пазиш, запазваш и показваш предметите на играча, а петовете работят по същия начин. Ръководството за излюпване на яйца изгражда хвърлянето на сървъра, а ръководството за петове кара петовете да летят до собственика си.

Зони, които се отключват с ребърти

Зоната е част от картата с по-добри награди зад бариера. Заключвай наградата, а не само вратата: всичко, което плаща в зоната, трябва да провери Rebirths на играча в таблицата на сървъра, преди да плати. Врата, която LocalScript отваря за подходящите играчи, става за вида, но експлойтърите могат да променят партовете и да местят персонажа си на своето устройство.

Автоклик като геймпас

Автокликер, който се продава като геймпас, трябва да работи на сървъра. Премести тялото на обработчика на Click във функция, например addClick(player), свържи ремоута с нея, а за притежателите на паса я викай от сървърен цикъл с task.wait(0.5), а не с остарелия wait. Тогава автокликовете влизат в същия лимит на секунда като обикновените кликове. Проверявай притежанието на сървъра чрез MarketplaceService:UserOwnsGamePassAsync, както прави ръководството за геймпасове за своите бонуси. Пасът 2x монети работи по същия начин: умножавай clickValue на сървъра за притежателите. Преди да сложиш цена, безплатният калкулатор за данъка върху Robux ще покаже колко ти носи всяка продажба след дела на Roblox, а калкулаторът за DevEx ще покаже колко струват тези Robux в щатски долари.

Глобален топ 10 по ребърти

leaderstats сравнява само играчите на един сървър. За да подредиш Rebirths на всички играчи, записвай ги в подредено хранилище за данни (ordered data store) и чети обратно най-горните записи, както в стъпка 4 от ръководството за класация. Подредените хранилища позволяват по-малко записи от обикновените, 30 + 5 × играчи на минута на сървър, затова записвай при излизане на играча и по таймер.

Много големи числа

Числата в Luau са double и пазят около 15 значещи цифри. IntValue пази цели числа до около 9.2 квинтилиона, но Roblox предупреждава, че стойности над 2^53 (около 9 квадрилиона) губят точност в скриптовете. С тези настройки цената на ребърта минава тази граница на 29-ия ребърт. Ако играта ти отива по-далеч, премини със стойностите в leaderstats на NumberValue (замени IntValue в двата скрипта), който пази много по-големи числа със същата точност от около 15 цифри, и добави суфикси в short().

На какво се крепи една игра симулатор

Симулаторът е игра на числа. Кликът, ъпгрейдът и ребъртът по-горе са целият цикъл; дали играчите ще останат, решава начинът, по който растат тези числа. На всеки няколко минути играчът трябва да може да си позволи нещо, което ще ускори следващите няколко минути, а всяка сесия трябва да завършва близо до цел, заради която ти се иска да се върнеш.

  • Растеж, който стига за дълго. Цените на ъпгрейдите растат по-бързо от дохода, затова всяко стъпало отнема малко повече време. Ребъртът нулира монетите заради постоянен множител, старата зона става бърза, а изкачването се усеща като ново.
  • Какво да събираш. Зони за отключване, петове от яйца, които умножават печалбата, и инструменти за ъпгрейд дават на играчите списък с цели освен едно число.
  • Големи числа, които остават четливи. Показвай 1.5M, а не 1500000, и пази числата така, че сървърът да може да ги сравнява, дори когато станат големи.

Монетизация, която подхожда на симулатор

Честите пасове умножават монетите, дават допълнителен слот за пет, отварят повече яйца наведнъж или включват автоклик. Продавай ги като геймпасове и ги проверявай на сървъра. Пакетите монети са developer products. Ако яйцата или каквото и да е със случаен резултат може да се купи за Robux или за валута, купена за Robux, Roblox изисква да показваш шансовете преди покупката: прочети paid random items (на английски), преди да изградиш магазина.

Какво връща играчите

Запазен напредък, нова зона или набор петове в обновленията, дневни награди, кодове, които се обявяват заедно с обновленията, и класация по ребърти. Други жанрове, всеки със свой цикъл, системи и план за изграждане: жанрове игри в Roblox.

Чести грешки и решения

Отвори прозореца Output (менюто Window, после Output), преди да натиснеш Play. Повечето проблеми извеждат там предупреждение или грешка с името на скрипта и реда.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("SimulatorRemotes")'

LocalScript чака ремоутите, които 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 услугите, както обяснява ръководството за DataStore.

Направи го с RoCode

Ако не ти се поставя това ръчно, RoCode може да го сглоби в плейса, който имаш отворен. Това е независим ИИ агент за код, не от Roblox: описваш системата в уеб чата му, а плъгинът му за Roblox Studio създава скриптовете в твоя Explorer, така че не трябва да копираш код от прозореца на чата.

Ти пишеш

Направи кликер симулатор: голям бутон Click, който дава монети, равни на моето ниво на Click Power, умножено по (ребърти + 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 не може да създава геймпасове и developer products или да качва мешове и икони на петове: това се прави в Creator Hub и Studio. С плъгин 3.9.11 или по-нов RoCode може да пуска плейтест на играта ти в Studio и да управлява тестов персонаж, за да провери дали всичко работи, а с плъгин 3.9.15 или по-нов тестовият персонаж може да натиска бутоните на екрана, например да натисне Click и да провери дали Coins са се увеличили. Сам решава кога да пусне плейтест, до 2 на изграждане плюс 1 за проверка на своята поправка, и проверява само това, което е избрал, така че тествай цикъла сам. Цял симулатор е няколко промпта, по една система наведнъж: как с RoCode да изграждаш по една система на промпт. Как RoCode се свързва със Studio.

Често задавани въпроси

Как да направя симулатор в Roblox без скриптове?

Работещият симулатор има нужда от скриптове: някой трябва да добавя монети, да проверява цените и да запазва напредъка. Можеш да поставиш трите скрипта от това ръководство както са и да променяш само числата в SimulatorConfig, или да ги оставиш да ги направи пакет от Creator Store, плъгин или ИИ агент и да провериш дали монетите ги решава сървърът. Варианти.

Как работи системата за ребърти?

Ребъртът сменя монетите и ъпгрейдите ти срещу постоянен бонус. В това ръководство първият ребърт струва 1 000 монети; той слага Coins на 0, Click Power на ниво 1 и добавя 1 към Rebirths, а след това всеки клик се умножава по Rebirths + 1. Всеки ребърт струва три пъти повече от предишния.

Как да направя симулатор на сила или фитнес?

Дай на играчите Tool, например гира, чийто LocalScript вика същия ремоут Click при Tool.Activated. Сървърът смята наградата точно както за клик по бутона. Свали сървърния лимит на кликовете до темпото на вдиганията, за да не може скрипт да спечели повече от играч. Скриптът е в раздела версия с гира.

Какви системи трябват в един симулатор?

Първо цикълът на печалба, ъпгрейди и ребърти, после запазване, после петове или друга колекция, която умножава печалбата, зони зад ребърти, класации, дневни награди и кодове и накрая геймпасове. В реда на изграждане има ръководство за всяка.

Колко трябва да трае един ребърт?

Достатъчно дълго, за да купят играчите първо няколко ъпгрейда, и достатъчно кратко, за да стигнат до един в първата сесия. С числата от това ръководство първият ребърт идва след около 1.2 минути при 5 клика в секунда; ако вдигнеш REBIRTH_BASE_COST на 10 000, ще е около 8 минути. Още настройки има в таблицата за темпото.

Как да се защитя от автокликери?

Сървърът отчита не повече от 15 клика на играч във всеки секунден прозорец и пренебрегва останалите. Под този лимит скриптът изглежда като бърз играч, така че икономиката я пази именно лимитът. Можеш също да продаваш автоклик като геймпас, който работи на сървъра.

Защо монетите се нулират при повторно влизане?

Засега нищо не ги запазва. Добави модула PlayerData от ръководството за DataStore, добави PowerLevel и Rebirths в неговите DEFAULTS и сложи SAVE_PROGRESS = true в SimulatorService, както в стъпка 4.

Как да добавя петове в симулатора?

Направи всеки пет множител, който сървърът прилага към кликовете. Отваряй яйцата на сървъра с претеглен случаен избор, запазвай id на петовете на играча заедно с останалите му данни и ги показвай в GUI за инвентар, както в ръководството за инвентар.

Кое е по-добро: клик по парт или по бутон?

Става и едното, и другото. Бутонът на екрана е удобен на телефони, а парт с ClickDetector подхожда на игра, в която всичко става в света. Според документацията на Roblox сървърът изобщо не проверява събитията на ClickDetector, така че ограничавай честотата на тези кликове на сървъра по същия начин.

Източници и какво да прочетеш

Как е проверен кодът: всеки скрипт на тази страница минава строга проверка на типовете в Luau с дефинициите на Roblox API (luau-lsp, 20 ноември 2026 г.). Проверката на типовете хваща грешки в имената на API и грешни типове, но не и грешки в логиката на играта, затова тествай всичко в Studio, преди да публикуваш.

Пробвай RoCode в своята игра.

Безплатни кредити всеки ден, без карта. Инсталирай плъгина, опиши функцията и виж какво се е появило в Studio.