Tutorial · Sisteme de joc

Cum să faci un simulator în Roblox

Aproape toate simulatoarele se învârt în aceeași buclă: faci ceva simplu și primești monedă, o cheltui pe upgrade-uri care o aduc mai repede, apoi faci un rebirth ca s-o iei de la capăt cu un multiplicator permanent. În acest ghid construim această buclă ca un clicker din trei scripturi, în care fiecare număr îl decide serverul, și salvăm progresul cu modulul PlayerData din tutorialul DataStore. Dacă n-ai făcut încă niciun joc în Studio, întâi fă un traseu scurt cu monede.

Actualizat 20 noiembrie 202625 min de cititAutor:

Pe scurt

Un simulator în Roblox e o singură buclă: dai clic ca să primești monede, le cheltui pe upgrade-uri care dau mai mult, apoi faci un rebirth pentru un multiplicator permanent. Ține prețurile într-un ModuleScript din ReplicatedStorage. Un singur Script în ServerScriptService ține pentru fiecare jucător Coins, Click Power și Rebirths, numără cel mult 15 clicuri pe secundă de la RemoteEvent-ul Click și vinde upgrade-uri și rebirth-uri printr-o RemoteFunction, după ce verifică prețul. Un LocalScript arată butoanele Click, Upgrade și Rebirth. Cu numerele din acest ghid, un jucător care dă clic de 5 ori pe secundă ajunge la primul rebirth în aproximativ 1.2 minute, iar tabelul de ritm arată ce schimbi ca urcarea să dureze mai mult.

  • Un clic nu transmite nimic în afară de clicul însuși. Cât valorează calculează serverul, așa că un client modificat nu își poate da monede.
  • Salvează tot tabelul după un cronometru și la ieșirea jucătorului, nu la fiecare clic. Roblox îi permite fiecărui server 60 + 40 × jucători scrieri într-un depozit de date pe minut.
  • Nu știi să scrii scripturi? Aceeași buclă o poate construi un kit din Creator Store, un plugin sau un agent AI. Verifică dacă monedele le decide serverul: variante.
  • Vrei o sală de forță sau o mină în loc de buton? Un Tool poate declanșa același remote Click: versiunea cu ganteră. Apoi adaugă sistemele după ordinea de construcție de mai jos.
Pe această pagină
  1. Cum funcționează
  2. 1. Modulul de setări
  3. 2. Scriptul de server
  4. 3. Butoane
  5. 4. Salvare
  6. De ce decide serverul
  7. 5. Verificare
  8. Versiunea cu ganteră
  9. Ordinea de construcție
  10. Fără scripting
  11. Cum extinzi
  12. Genul
  13. Common errors
  14. Cu RoCode
  15. Întrebări frecvente
  16. Surse și lecturi suplimentare

Cum e construită bucla principală a unui simulator

IlustrațieJucătorul cumpără nivelul 2 de Click Power pe 10 monede, apoi (accelerat) strânge 1 000 de monede și face un rebirth: monedele și upgrade-urile se resetează, iar fiecare clic valorează x2.

Un simulator e o buclă din trei acțiuni. Jucătorul face iar și iar ceva simplu ca să câștige monedă, o cheltuie pe upgrade-uri care o aduc mai repede, iar când upgrade-urile devin scumpe, face un rebirth: dă monedele și upgrade-urile pe un bonus care rămâne pentru totdeauna și urcă din nou, mai repede. În alte simulatoare, în loc de clic se ridică ganterele, se sapă sau se strâng obiecte, dar bucla de dedesubt e aceeași.

Cele trei acțiuni din bucla acestui ghid
AcțiuneCât costăCe dăCine decide
ClicNimicMonede egale cu Click Power × (Rebirths + 1)Serverul, care numără cel mult 15 clicuri în fiecare fereastră de o secundă
Upgrade10 monede, apoi de 1.5 ori prețul anterior pentru fiecare nivelÎncă un nivel de Click Power, până la al 50-leaServerul, după propria copie a prețurilor
Rebirth1 000 de monede, apoi de 3 ori prețul anterior pentru fiecare rebirthMonedele înapoi la 0 și Click Power înapoi la nivelul 1, plus un +1 permanent la multiplicatorServerul

Fiecare număr trăiește pe server. Dispozitivul jucătorului desenează butoanele și cere ("am dat clic", "vreau un upgrade"), iar serverul decide cât valorează și dacă se poate face. Scripturile de clicker care se sparg adaugă adesea monede într-un LocalScript sau îl lasă pe client să trimită câte monede să adauge.

Din ce e alcătuit simulatorul
ElementUnde se aflăCe face
ModuleScript SimulatorConfigReplicatedStoragePrețuri, limite și formule pentru valoarea unui clic, prețul unui upgrade și prețul unui rebirth. Îl citesc ambele părți.
Script SimulatorServiceServerScriptServiceȚine numerele fiecărui jucător, tratează clicurile, upgrade-urile și rebirth-urile și completează leaderstats.
Folder SimulatorRemotesReplicatedStorage (îl creează SimulatorService)RemoteEvent-ul Click și RemoteFunction-urile BuyUpgrade și Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsConstruiește butoanele, trimite clicurile și cererile și arată numerele serverului.
ModuleScript PlayerData (opțional)ServerScriptServiceSalvează progresul între intrări. E luat din tutorialul DataStore și îți trebuie doar la pasul 4.
Explorer-ul în timpul jocului. SimulatorService creează SimulatorRemotes și cele trei remote-uri la pornirea jocului, iar PlayerData apare doar după ce adaugi salvarea la pasul 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

Pasul 1: mută prețurile și formulele într-un modul

Fiecare număr pe care ai putea vrea să-l reglezi merge într-un singur ModuleScript: cât valorează un clic, cât costă fiecare upgrade și rebirth și limita de clicuri. Serverul decide după el, iar LocalScript-ul ia din el prețurile pentru butoane, așa că orice schimbare e o singură editare într-un singur loc.

  1. În Explorer treci cu mouse-ul peste ReplicatedStorage, apasă butonul + și inserează un ModuleScript.
  2. Redenumește-l în SimulatorConfig (numele țin cont de majuscule) și înlocuiește-i conținutul cu codul de mai jos.
ModuleScript în ReplicatedStorage cu numele SimulatorConfig
-- Toate numerele buclei principale și formulele pe care le folosesc ambele părți. Clientul doar
-- arată prețurile după ele; serverul decide după propria lui copie.

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- prețul nivelului 2 de Click Power
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- fiecare nivel costă de 1.5 ori mai mult decât cel anterior
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- monede pentru primul rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- fiecare rebirth costă de 3 ori mai mult decât cel anterior
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- clicurile peste acest număr într-o secundă sunt ignorate

-- Monede pe un clic: nivelul Click Power înmulțit cu 1 + numărul de rebirth-uri
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- Prețul următorului nivel de Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- Monedele necesare pentru următorul rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

Jucătorii pot citi un ModuleScript din ReplicatedStorage, așa că aceste prețuri sunt publice. E în regulă: oricum sunt scrise pe butoane. Clientul și serverul rulează fiecare propria copie a modulului, așa că un jucător care schimbă numerele pe dispozitivul lui nu schimbă nimic pe server.

Ce dau formulele cu aceste setări
Nivel Click PowerPrețul nivelului următorMonede pe clic, fără rebirthMonede pe clic, 1 rebirth
11012
21524
32236
43348
550510

Rebirth-urile costă 1 000 de monede, apoi 3 000, apoi 9 000, pentru că rebirthCost înmulțește de fiecare dată prețul cu 3. După un rebirth fiecare clic valorează de două ori mai mult, după două de trei ori, și așa mai departe.

Cât durează un rebirth cu aceste numere

Formulele decid cât durează bucla, așa că merită să calculezi numerele înainte să le calculeze jucătorii. Tabelul presupune că jucătorul face un rebirth imediat ce și-l permite, iar în rest cumpără următorul nivel de Click Power când și-l permite și când costă mai puțin decât un rebirth. Timpul se numără de la un start nou, așa că ultima coloană e timpul total până la 3 rebirth-uri.

Minute de la un start nou până la fiecare rebirth la 5 clicuri pe secundă, după REBIRTH_BASE_COST. Calculat după formulele SimulatorConfig, nu măsurat pe jucători
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1 000 (acest ghid)1.22.74.8
5 0004.310.118.3
10 0008.216.933.2
25 00016.740.174.5
50 00032.868.8137.8

Fără rebirth-uri, nivelul 5 de Click Power vine după 34 de clicuri, nivelul 10 după 122, iar nivelul 13 după 285. Cu numerele implicite jucătorul nu mai cumpără upgrade-uri după asta, pentru că nivelul 14 costă 1 297 de monede, mai mult decât un rebirth de 1 000 de monede, iar primul rebirth vine după 362 de clicuri în total. La limita serverului de 15 clicuri pe secundă, împarte fiecare timp la 3. Schimbi orice număr din SimulatorConfig, iar aceste timpuri se schimbă odată cu el, așa că recalculează-le.

Reglarea creșterii

Cele două numere _GROWTH stabilesc cât de repede cresc prețurile. La 1.5, fiecare upgrade costă de o dată și jumătate mai mult decât cel anterior, iar fiecare nivel adaugă doar o monedă pe clic (înainte de multiplicatorul de rebirth), așa că fiecare nivel nou se amortizează tot mai greu. Tocmai această încetinire face rebirth-ul avantajos. Mărește creșterea pentru o urcare mai lungă, scade-o pentru una mai rapidă și ține REBIRTH_BASE_COST destul de mare cât jucătorii să cumpere câteva upgrade-uri înainte de primul rebirth.

Ca primul rebirth să vină după câteva minute, nu după aproximativ unul, ridică REBIRTH_BASE_COST la 5 000 sau 10 000.

Pasul 2: adaugă scriptul de server

Acest Script deține fiecare număr. Creează remote-urile, îi dă fiecărui jucător un folder leaderstats cu Coins și Rebirths și răspunde la trei cereri. Treci cu mouse-ul peste ServerScriptService, inserează un Script, redenumește-l în SimulatorService și înlocuiește-i conținutul cu acest cod:

Script în ServerScriptService cu numele SimulatorService
-- Deține fiecare număr: clicurile aduc monede aici, upgrade-urile și rebirth-urile se cumpără aici,
-- iar leaderstats doar arată rezultatul.

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- false: la fiecare intrare toți încep de la zero. true: încărcare și salvare prin modulul PlayerData
-- din tutorialul DataStore (adaugă întâi PowerLevel = 1 și Rebirths = 0 în DEFAULTS-ul lui).
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 } = {} -- când a început fereastra curentă de o secundă a acestui jucător
local clickCount: { [Player]: number } = {} -- clicurile numărate în această fereastră

-- Copiază numerele serverului acolo unde le văd jucătorii: în leaderstats și într-un atribut
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

-- Pornește jucătorul cu datele primite (numere noi sau tabelul salvat)
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

-- Un clic nu poartă numere: cât valorează, calculează serverul
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 -- un autoclicker sau un script care declanșează remote-ul într-o buclă
	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-ul schimbă monedele și upgrade-urile pe un multiplicator permanent
	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

-- Numerele de start: noi sau tabelul pe care îl încarcă și îl salvează modulul 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) -- același tabel pe care îl salvează PlayerData, așa că se salvează fiecare schimbare
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- toți cei ale căror date s-au încărcat înainte să pornească acest script
	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 ajunge la jucător ca atributul PowerLevel pe obiectul lui Player, nu ca a treia valoare din leaderstats, așa că lista de jucători arată doar Coins și Rebirths. Atributele setate de server se replică pe dispozitivul jucătorului; o schimbare pe care jucătorul o face pe dispozitivul lui rămâne acolo.

Clicuri și limita de frecvență

Remote-ul Click nu transmite argumente. Pe server, primul parametru al handler-ului OnServerEvent e mereu jucătorul care l-a declanșat, așa că serverul știe cine a dat clic, îi ia nivelul Click Power și Rebirths și adaugă clickValue la Coins-ul lui. În cerere nu e nimic ce ar putea schimba un trișor.

Ghidul de securitate Roblox spune să nu te bazezi niciodată doar pe o limită de frecvență pe client, iar darea de monedă e acolo printre acțiunile care trebuie limitate. Serverul numără clicurile fiecărui jucător în ferestre de câte o secundă: primul clic deschide fereastra, iar când s-au numărat 15 clicuri, restul sunt ignorate până trece o secundă de la începutul ferestrei. Un script care declanșează remote-ul într-o buclă primește cel mult 15 clicuri numărate în fiecare fereastră. Ca să permiți clicuri mai rapide sau mai lente, schimbă MAX_CLICKS_PER_SECOND în SimulatorConfig.

Upgrade-uri și rebirth-uri

BuyUpgrade și Rebirth sunt RemoteFunction-uri, așa că butonul poate aștepta răspunsul și îl poate arăta. Fiecare handler ia prețul din copia de pe server a SimulatorConfig, verifică Coins-ul jucătorului și abia apoi schimbă ceva. Returnează true sau false și un mesaj, de exemplu "You need 5 more coins.", pe care LocalScript-ul îl arată în rândul de stare.

Între verificarea prețului și schimbare nimic nu așteaptă și nu cedează execuția (yield), așa că două cereri de la același jucător nu pot trece amândouă de verificare înainte ca prima să ia monedele. Rebirth-ul setează Coins la 0, Click Power la nivelul 1 și adaugă 1 la Rebirths, iar formula clicului transformă asta în multiplicatorul Rebirths + 1.

Comutatorul SAVE_PROGRESS

Cu SAVE_PROGRESS = false, fiecare jucător începe la fiecare intrare cu 0 monede, și exact asta vrei cât construiești jocul. Pasul 4 îl activează. Atunci scriptul așteaptă ca modulul PlayerData să încarce fiecare jucător și lucrează direct cu tabelul pe care îl salvează acel modul, așa că fiecare monedă și fiecare rebirth se salvează fără cod în plus.

Pasul 3: construiește butoanele

Acest LocalScript construiește tot ecranul în cod: contorul de monede sus, butonul mare Click la mijloc, butoanele Upgrade și Rebirth jos și un rând de stare pentru răspunsurile serverului. Singur nu schimbă niciodată niciun număr.

  1. În Explorer deschide StarterPlayer, treci cu mouse-ul peste StarterPlayerScripts și inserează un LocalScript numit SimulatorClient.
  2. Înlocuiește-i conținutul cu codul de mai jos și apasă Play.
LocalScript în StarterPlayerScripts cu numele SimulatorClient
-- Construiește butoanele simulatorului și arată numerele serverului. Singur nu le schimbă niciodată.

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))
-- Butonul Click rămâne pătrat, pe măsura ecranului și nu mai mare de 200 pe 200,
-- ca pe telefon să încapă între contorul de monede și butoanele de jos
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"-ul care apare deasupra butonului. Numărul e doar o estimare de formă;
-- cât valorează de fapt clicul decide serverul.
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)

Butoanele folosesc Activated, pe care Roblox îl declanșează la un clic stânga pe calculator, la o atingere pe telefon și la apăsarea lui A (sau X) pe gamepad, în modul de navigare prin UI.

Pe gamepad, A apasă doar butonul selectat. Când e activat GuiService.AutoSelectGuiEnabled, butonul Select de pe gamepad îți selectează butoanele de pe ecran; mai departe jucătorii pot trece de la unul la altul și pot apăsa A. Dacă vrei ca un buton de gamepad să dea clic direct, leagă-l prin ContextActionService și declanșează din el același remote Click.

Patru detalii din script:

  • Butonul Click se scalează după ecran. Mărimea lui e o fracție din ecran, UIAspectRatioConstraint îl ține pătrat, iar UISizeConstraint îl limitează la 200 pe 200 de pixeli. Pe un monitor are 200 de pixeli lățime; pe un telefon se micșorează și încape între contorul de monede și butoanele de jos. Dacă muți elementele, ține-l departe de ele: Rebirth nu are confirmare, așa că o atingere accidentală poate reseta monedele și upgrade-urile jucătorului.
  • "+N"-ul care apare e doar de formă. Folosește copia de pe client a formulei. Dacă serverul ignoră clicul din cauza limitei de frecvență, "+N"-ul apare totuși, dar monedele nu se schimbă.
  • short() face numerele mari lizibile. 1 234 se arată ca 1.2K, iar 5 600 000 ca 5.6M. Funcția rotunjește în jos, așa că contorul nu arată niciodată mai mult decât ai. Pentru numere mai mari de T (trilioane), adaugă intrări în UNITS.
  • Ecranul se actualizează la evenimente. Ascultă valorile Coins și Rebirths și atributul PowerLevel, așa că prețurile de pe butoane sunt corecte, oricum s-ar schimba numerele.

ScreenGui-ul are ResetOnSpawn la false, așa că rămâne când personajul reapare. Aici contează: un LocalScript din StarterPlayerScripts se copiază la jucător o singură dată, la intrare, așa că n-ar mai construi ecranul din nou.

Pasul 4: salvează progresul prin PlayerData

Deocamdată totul se resetează când jucătorul iese. În loc de un al doilea script de salvare, simulatorul se leagă de modulul PlayerData din tutorialul DataStore. Acest modul deja reîncearcă cererile eșuate, salvează automat la fiecare 180 de secunde, salvează la ieșirea jucătorului și la oprirea serverului și nu salvează niciodată un jucător ale cărui date nu s-au încărcat.

  1. Parcurge pasul 1 din tutorialul DataStore ca să adaugi ModuleScript-ul PlayerData în ServerScriptService. Ca să verifici salvarea în Studio, activează accesul Studio la serviciile API într-o copie de test a jocului, cum explică prima lui secțiune. SimulatorService include singur modulul prin require, așa că scriptul Main din tutorial nu e necesar aici.
  2. În PlayerData adaugă PowerLevel = 1, și Rebirths = 0, în tabelul DEFAULTS, lângă Coins = 0,.
  3. În același modul adaugă PowerLevel: number, și Rebirths: number, în tipul Data, ca verificarea strictă de tipuri să știe de noile câmpuri.
  4. În SimulatorService înlocuiește local SAVE_PROGRESS = false cu local SAVE_PROGRESS = true.

Jucătorii care s-au salvat înainte să adaugi câmpurile le primesc automat: funcția migrate din PlayerData completează toate câmpurile din DEFAULTS care lipsesc din tabelul salvat, așa că încep cu nivelul 1 de Click Power și 0 rebirth-uri și își păstrează Coins. Dacă sari peste punctul 2, SimulatorService afișează un avertisment cu câmpurile de adăugat și nu pornește jucătorul.

De ce scrie simulatorul în tabelul PlayerData

Când salvarea e activată, SimulatorService nu copiază numerele nicăieri. PlayerData.Get(player) returnează tabelul live pe care îl salvează modulul, iar simulatorul schimbă Coins, PowerLevel și Rebirths chiar în acest tabel. Fiecare număr are o singură copie, iar în depozitul de date scrie un singur script. Două scripturi care salvează aceeași cheie se suprascriu unul pe altul, iar unul dintre ele poate salva numere vechi peste numerele celuilalt.

Nu face și leaderstats în handler-ul Loaded, cum recomandă tutorialul DataStore pentru alte jocuri: SimulatorService face deja Coins și Rebirths din tabelul încărcat. Dacă leaderstats le face deja un script de clasament, șterge-l.

De ce să nu salvezi la fiecare clic

Roblox îi permite fiecărui server 60 + 40 × jucători scrieri într-un depozit de date obișnuit pe minut (restul e în tabelul de limite din tutorialul DataStore). Salvarea la fiecare clic, la 15 clicuri pe secundă, înseamnă 900 de scrieri pe minut pentru un singur jucător, mult peste cele 100 pe care le primește un server cu un jucător. Salvarea întregului tabel la fiecare 180 de secunde, la ieșirea jucătorului și la oprirea serverului costă doar câteva scrieri pe jucător, iar la o cădere se pierde cel mult progresul de la ultima salvare automată.

Dacă încărcarea a eșuat, modulul îl lasă pe jucător să joace cu numere noi, dar nu le salvează niciodată, așa că o încărcare proastă nu poate șterge progresul real. Tutorialul explică cum tratează modulul asta.

De ce fiecare număr îl decide serverul

Exploiterii își controlează dispozitivul. Ghidul de securitate Roblox spune că pot schimba orice în copia lor locală a jocului și pot declanșa orice RemoteEvent sau RemoteFunction de oricâte ori, cu orice argumente. Economia unui simulator e protejată exact atât cât e protejat scriptul lui de server.

Ce poate încerca un exploiter și ce face SimulatorService
Exploiterul încearcăDacă ar decide clientulCe face SimulatorService
Să declanșeze Click într-o buclă cât de repede poateMonede nelimitateNumără cel mult 15 clicuri în fiecare fereastră de o secundă și le ignoră pe celelalte.
Să trimită o cantitate de monede împreună cu cliculÎși alege singur recompensaIgnoră orice argument. Valoarea clicului vine din numerele serverului.
Să cumpere un upgrade sau un rebirth fără monedele necesareUpgrade-uri gratuiteCompară prețul cu Coins de pe server și răspunde "You need N more coins."
Să schimbe Coins din leaderstats pe ecranul luiCheltuie monede pe care nu le areNu citește niciodată leaderstats. Doar scrie acolo din tabelul lui.
Să seteze atributul PowerLevel pe Player-ul luiUn clic mai puternicNu citește niciodată acest atribut, iar schimbarea rămâne pe dispozitivul jucătorului.
Să declanșeze Rebirth de două ori în același momentDouă rebirth-uri la prețul unuiaVerifică din nou prețul la fiecare apel, iar între verificare și schimbare nimic nu cedează execuția.
Să schimbe prețurile în copia lui a SimulatorConfigUpgrade-uri mai ieftineFolosește propria copie a modulului.

Regula se aplică fiecărui remote din simulator: trimite ce vrea jucătorul să facă, nu cât costă. În ghidul despre RemoteEvent verificarea argumentelor remote-urilor e explicată mai în detaliu.

Ce să eviți în scripturile de clicker copiate

Trucuri frecvente din tutorialele vechi de clicker și ce face ghidul acesta în schimb
TrucProblemaGhidul acesta
Un LocalScript adaugă monede prin leaderstats.Coins.Value += 1Schimbarea rămâne pe un singur dispozitiv, iar dispozitivul lui îl controlează exploiterulMonedele le adaugă serverul
clickEvent:FireServer(amount)Clientul își alege singur recompensaClick nu transmite argumente
Nicio limită de frecvență pe serverDocumentația Roblox spune să nu te bazezi niciodată doar pe o limită pe clientCel mult 15 clicuri în fiecare fereastră de o secundă
SetAsync la fiecare clic sau upgradeMănâncă limita de scrieri a serveruluiPlayerData salvează la fiecare 180 de secunde, la ieșire și la oprire. Salvează imediat prin PlayerData.SaveNow doar după ceva ce nu poate fi pierdut, de exemplu o cumpărare pe Robux.
Un al doilea script de depozit de date doar pentru simulatorDouă scripturi care salvează aceeași cheie se suprascriu unul pe altulScrie în tabelul PlayerData
Bucle while wait(1) do pentru venit pasivRoblox marchează funcția globală wait ca învechită, înlocuită de task.waittask.wait (vezi Cum extinzi)
MouseButton1Click pe butoaneE descris pentru clicuri de mouseActivated, pentru mouse, atingeri și gamepad

Pasul 5: verifică

Parcurge punctele de la 1 la 8 cu SAVE_PROGRESS = false în SimulatorService, ca fiecare playtest să înceapă cu numere noi. Dacă ai activat deja salvarea la pasul 4, pune-l deocamdată pe false, iar pentru punctul 9 pune-l înapoi pe true.

  1. Apasă Play. Sus pe ecran scrie 0 coins, pe butonul verde Upgrade: 10, iar pe cel portocaliu Rebirth: 1.0K.
  2. Apasă de zece ori butonul mov Click!. Fiecare clic arată un +1 auriu, iar Coins din lista de jucători crește cu 1.
  3. Apasă Upgrade. Monedele revin la 0, rândul de stare devine verde cu textul "Click Power is now level 2.", iar pe buton scrie acum Upgrade: 15. De acum fiecare clic dă 2 monede.
  4. Fără să dai clic, apasă Rebirth. Rândul de stare scrie "You need 1000 more coins to rebirth." și nu se schimbă nimic.
  5. Ca să verifici rebirth-ul fără 1 000 de clicuri, oprește testul, schimbă Coins = 0 în Coins = 1000 pe rândul de lângă finalul SimulatorService care pornește jucătorii noi și apasă Play. Apasă Rebirth: Coins devine 0, Rebirths din lista de jucători devine 1, rândul de stare scrie "Rebirth 1! Every click is now worth x2.", iar pe buton scrie acum Rebirth: 3.0K. Fiecare clic dă acum 2 monede la nivelul 1 de Click Power. Apoi pune rândul înapoi pe 0.
  6. Ca să vezi limita de frecvență, setează MAX_CLICKS_PER_SECOND în SimulatorConfig la 2 și dă clic repede. "+N"-urile continuă să apară, dar Coins crește cel mult cu valoarea a 2 clicuri pe secundă. Pune înapoi 15.
  7. Alege un telefon în Device Simulator din Studio (e o beta Studio; merge și vechiul Device Emulator) și apasă Play. Verifică dacă butonul Click nu intră nici peste contorul de monede, nici peste butoanele Upgrade și Rebirth și dacă rândul de stare se vede la apăsarea Upgrade și nu e acoperit de buton.
  8. Conectează un gamepad sau deschide Controller Emulator din Studio (Controller în fila Emulation) în timpul unui playtest, apasă Select și verifică dacă poți ajunge la cele trei butoane și le poți apăsa cu A.
  9. Cu salvarea activată (pasul 4) și din nou SAVE_PROGRESS = true, câștigă câteva monede, apasă Stop, apoi din nou Play. Coins, nivelul Click Power și Rebirths revin.

Fă un simulator de sală de forță sau de mină

Multe simulatoare înlocuiesc butonul cu o acțiune în lume: ridici o ganteră, lovești cu târnăcopul, rotești o sabie prin aer. Dedesubt e același clic. Un Tool poate declanșa același remote Click, așa că SimulatorService, prețurile lui și limita lui de frecvență rămân cum sunt.

  1. În Explorer treci cu mouse-ul peste StarterPack, inserează un Tool și numește-l Dumbbell. Inserează în el un Part numit Handle, dă-i forma unei gantere și debifează Anchored, ca în pașii cu Tool din ghidul despre sabie.
  2. Inserează în Tool un LocalScript numit LiftClient și lipește codul de mai jos.
  3. Apasă Play, ia gantera și dă clic. Monedele cresc cu Click Power-ul tău la fiecare ridicare, exact ca la buton.
LocalScript în Tool-ul Dumbbell din StarterPack cu numele LiftClient
-- LocalScript în Tool-ul Dumbbell, cu numele LiftClient.
-- Fiecare ridicare e un clic: declanșează același remote Click ca butonul, iar serverul
-- decide cât valorează și câte ridicări numără.

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 -- timpul dintre ridicări pe acest dispozitiv; serverul are propria limită
local LIFT_ANIMATION_ID = "" -- opțional: "rbxassetid://" urmat de id-ul animației tale

local player = Players.LocalPlayer
local lastLift = 0
local liftTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil

-- Încărcăm animația de ridicare o dată pe personaj, prin Animator-ul pe care Roblox îl pune în 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() -- fără argumente: recompensa o calculează serverul
end)

Pentru o animație de ridicare, fă-o în Animation Editor cu prioritatea Action, public-o și pune-i ID-ul în LIFT_ANIMATION_ID. Pașii cu animația din ghidul despre sabie funcționează la fel.

  • Potrivește limita serverului cu acțiunea. LIFT_SECONDS îi frânează doar pe jucătorii cinstiți: un trișor poate declanșa Click din propriul cod. Dacă ridicarea e singurul mod de a câștiga, scade MAX_CLICKS_PER_SECOND în SimulatorConfig la ritmul real, de exemplu la 2 pentru o ridicare la fiecare 0.5 secunde, ca un script să nu poată câștiga mai mult decât un jucător. Apoi recalculează tabelul de ritm: fiecare timp din el e calculat pentru 5 clicuri pe secundă.
  • Păstrează sau ascunde butonul. Butonul Click continuă să meargă alături de Tool. Ca să-l ascunzi, adaugă clickButton.Visible = false imediat după rândul din SimulatorClient care creează clickButton.
  • Câștig doar în locul potrivit. Ca să plătești doar în sală sau în mină, verifică pe server unde e personajul înainte să numeri clicul, de exemplu după distanța până la un part din acea zonă. O verificare în LiftClient n-ar opri pe nimeni.

Ce faci mai departe: ordinea de construcție a unui simulator

Un simulator e o stivă de sisteme peste această buclă. Construiește-le în această ordine, ca fiecare să aibă ce înmulți, și fă un playtest după fiecare. Iată ordinea pe care o recomandăm, cu un ghid pentru fiecare pas.

Ordinea de construcție a unui simulator în Roblox, de la bucla principală spre exterior
OrdineSistemGhidDe ce tocmai acum
1Câștig, upgrade, rebirthAcest ghidTot restul înmulțește această buclă, așa că întâi reglează-i numerele după tabelul de ritm.
2SalvareTutorialul DataStore, apoi pasul 4Un progres care se resetează la reintrare omoară un simulator. Adaugă-l înaintea a orice pot pierde jucătorii.
3Ouă și pet-uri ca multiplicatoriDeschiderea ouălor și pet-uri care urmează jucătorulUn al doilea obiectiv lângă monede: ceva de colecționat care face fiecare clic mai valoros.
4Zone după rebirth-uriCum extinziUnde să mergi după un rebirth, cu recompense mai bune, verificate de server.
5ClasamenteGhidul despre clasamentUn top 10 global după rebirth-uri dă sens urcării lungi.
6Recompense zilnice și coduriRecompense zilnice și coduriMotive să revii mâine și după fiecare update.
7Gamepass-uriGhidul despre gamepass-uri2x monede, autoclic sau un slot în plus pentru pet-uri, cu verificare pe server. Vinde-le când bucla gratuită e deja interesantă.

Pentru ecrane, kiturile UI pentru Roblox gratuite includ ecrane în stil de simulator, împreună cu scripturile care le fac să funcționeze.

Cum faci un simulator fără să scrii scripturi

Un simulator tot are nevoie de scripturi: cineva trebuie să adauge monedele, să verifice prețurile și să salveze. Nu e obligatoriu să le scrii tu:

  • Un kit de simulator din Creator Store. Citește-i scripturile înainte de publicare și verifică dacă monedele se schimbă doar într-un Script de server, nu într-un LocalScript.
  • Un plugin generator de simulatoare. Aceeași verificare pentru tot ce creează.
  • Un agent AI în Studio, de exemplu RoCode, care poate construi aceleași trei scripturi în place-ul pe care îl ai deschis.
  • Build în aplicația mobilă Roblox. Conform documentației Roblox, face după descriere jocuri mai simple 2D și 2.5D, de exemplu clickere, și se lansează treptat pe regiuni.

Orice ai alege, trece rezultatul prin verificările de la pasul 5 și prin verificările contra exploit-urilor din secțiunea De ce fiecare număr îl decide serverul.

Cum extinzi: pet-uri, zone, autoclic și clasamente

Pet-uri ca multiplicatori

O variantă frecventă: fiecare pet e un multiplicator. Ține lista de id-uri ale pet-urilor jucătorului în tabelul lui salvat, iar serverul să înmulțească clickValue cu bonusul fiecărui pet echipat. Deschide ouăle pe server: clientul cere deschiderea unui ou, serverul verifică și ia prețul, apoi alege pet-ul printr-o tragere aleatorie ponderată. Nu lăsa niciodată clientul să tragă pentru un ou sau să spună ce pet a ieșit. Ghidul despre inventar arată cum păstrezi, salvezi și afișezi obiectele unui jucător, iar pet-urile funcționează la fel. Ghidul despre deschiderea ouălor construiește tragerea pe server, iar ghidul despre pet-uri face pet-urile să plutească lângă proprietar.

Zone care se deblochează prin rebirth-uri

O zonă e o parte a hărții cu recompense mai bune, după o barieră. Blochează recompensa, nu doar ușa: tot ce plătește în zonă trebuie să verifice Rebirths-ul jucătorului din tabelul serverului înainte să plătească. O ușă pe care un LocalScript o deschide jucătorilor potriviți e bună pentru aspect, dar exploiterii pot schimba part-uri și își pot mișca personajul pe dispozitivul lor.

Autoclic ca gamepass

Un autoclicker vândut ca gamepass trebuie să ruleze pe server. Mută corpul handler-ului Click într-o funcție, de exemplu addClick(player), conectează remote-ul la ea, iar pentru proprietarii pass-ului apeleaz-o dintr-o buclă de server cu task.wait(0.5), nu cu wait-ul învechit. Atunci autoclicurile intră în aceeași limită pe secundă ca și clicurile obișnuite. Verifică proprietatea pe server prin MarketplaceService:UserOwnsGamePassAsync, cum face ghidul despre gamepass-uri pentru bonusurile lui. Un pass 2x monede funcționează la fel: înmulțește clickValue pe server pentru proprietari. Înainte să pui un preț, calculatorul gratuit de taxă Robux îți arată cât îți aduce fiecare vânzare după partea Roblox, iar calculatorul DevEx arată cât valorează acei Robux în dolari americani.

Un top 10 global după rebirth-uri

leaderstats compară doar jucătorii de pe același server. Ca să ordonezi Rebirths-ul tuturor jucătorilor, scrie-le într-un depozit de date ordonat (ordered data store) și citește înapoi primele intrări, ca la pasul 4 din ghidul despre clasament. Depozitele ordonate permit mai puține scrieri decât cele obișnuite, 30 + 5 × jucători pe minut pe server, așa că scrie la ieșirea jucătorului și după un cronometru.

Numere foarte mari

Numerele în Luau sunt double, păstrează în jur de 15 cifre semnificative. Un IntValue păstrează întregi până la aproximativ 9.2 chintilioane, dar Roblox avertizează că valorile peste 2^53 (în jur de 9 cvadrilioane) își pierd precizia în scripturi. Cu aceste setări, prețul rebirth-ului trece de acest prag la al 29-lea rebirth. Dacă jocul tău merge mai departe, mută valorile leaderstats pe NumberValue (înlocuiește IntValue în ambele scripturi), care păstrează numere mult mai mari cu aceeași precizie de aproximativ 15 cifre, și adaugă sufixe în short().

Pe ce se sprijină un joc de tip simulator

Un simulator e un joc al numerelor. Clicul, upgrade-ul și rebirth-ul de mai sus sunt toată bucla; dacă jucătorii rămân decide felul în care cresc aceste numere. La fiecare câteva minute, jucătorul trebuie să-și permită ceva ce accelerează următoarele câteva minute, iar fiecare sesiune trebuie să se termine aproape de un obiectiv pentru care vrei să revii.

  • O creștere care ține mult. Prețurile upgrade-urilor cresc mai repede decât venitul, așa că fiecare treaptă durează puțin mai mult. Rebirth-ul resetează monedele pentru un multiplicator permanent, iar zona veche devine rapidă și urcarea pare nouă.
  • Ceva de colecționat. Zone de deblocat, pet-uri din ouă care înmulțesc câștigul și instrumente de îmbunătățit le dau jucătorilor o listă de obiective în afară de un singur număr.
  • Numere mari care rămân lizibile. Arată 1.5M, nu 1500000, și ține numerele astfel încât serverul să le poată compara chiar și când devin mari.

Monetizare potrivită pentru un simulator

Pass-urile frecvente înmulțesc monedele, dau un slot în plus pentru pet-uri, deschid mai multe ouă odată sau activează autoclicul. Vinde-le ca gamepass-uri și verifică-le pe server. Pachetele de monede sunt developer products. Dacă ouăle sau orice cu un rezultat aleatoriu se pot cumpăra pe Robux sau pe o monedă cumpărată pe Robux, Roblox cere să arăți șansele înainte de cumpărare: citește paid random items (în engleză) înainte să construiești magazinul.

Ce îi aduce pe jucători înapoi

Progresul salvat, o zonă nouă sau un set nou de pet-uri în update-uri, recompense zilnice, coduri anunțate odată cu update-urile și un clasament după rebirth-uri. Alte genuri, fiecare cu bucla, sistemele și planul lui de construcție: genurile de jocuri din Roblox.

Erori frecvente și soluții

Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play. Cele mai multe probleme afișează acolo un avertisment sau o eroare cu numele scriptului și rândul.

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

LocalScript-ul așteaptă remote-urile pe care SimulatorService le creează la pornire. Verifică dacă SimulatorService e un Script, nu un LocalScript, dacă stă în ServerScriptService și dacă nu are o eroare în Output. Același avertisment pentru SimulatorConfig înseamnă că modulul nu e în ReplicatedStorage sau are alt nume.

Butoanele nu apar deloc

LocalScript-ul îți așteaptă leaderstats înainte să construiască ecranul. Dacă în Output scrie Infinite yield possible pe leaderstats, SimulatorService încă nu te-a pornit. Cu SAVE_PROGRESS = true așteaptă PlayerData, așa că verifică dacă PlayerData stă în ServerScriptService și se încarcă fără erori.

În Output scrie "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"

Salvarea e activată, dar modulul PlayerData nu are încă noile câmpuri. Adaugă-le în DEFAULTS-ul lui, ca la pasul 4, și apasă din nou Play.

"+1"-urile apar, dar monedele nu cresc

Serverul nu numără clicurile. Fie SimulatorService are o eroare (caută text roșu de la el în Output), fie clicurile vin mai repede decât permite MAX_CLICKS_PER_SECOND. Dacă jucătorii ating limita în joc obișnuit, ridic-o în SimulatorConfig.

Rândul de stare scrie "No answer from the server. Try again."

Apelul BuyUpgrade sau Rebirth a căzut, nu a returnat un răspuns. Cauza obișnuită e o eroare în SimulatorService în timpul tratării cererii, așa că caută o eroare roșie de la el în Output: acolo e indicat rândul.

Contorul de monede de pe ecran și lista de jucători arată numere diferite

Încă un script face și el un folder leaderstats, așa că fiecare jucător are două, iar LocalScript-ul îl poate citi pe celălalt. Șterge scriptul în plus: SimulatorService face singur Coins și Rebirths.

Monedele se resetează la fiecare reintrare

Salvarea e dezactivată. Parcurge pasul 4. Dacă e activată, iar monedele tot se resetează în Studio, verifică dacă în copia de test e activat accesul Studio la serviciile API, cum explică tutorialul DataStore.

Fă-o cu RoCode

Dacă nu ai chef să lipești asta manual, RoCode o poate construi în place-ul pe care îl ai deschis. E un agent AI independent pentru cod, nu de la Roblox: descrii sistemul în chatul lui web, iar pluginul lui pentru Roblox Studio creează scripturile în Explorer-ul tău, așa că nu trebuie să copiezi cod din fereastra de chat.

Tu scrii

Fă un clicker simulator: un buton mare Click care dă monede egale cu nivelul meu Click Power înmulțit cu (rebirth-uri + 1), un buton Upgrade care costă 10 monede și se scumpește de 1.5 ori cu fiecare nivel și un buton Rebirth pe 1 000 de monede care resetează monedele și upgrade-urile. Ține numerele pe server și limitează clicurile la 15 pe secundă. Am deja un modul PlayerData.

RoCode face
  • Poate citi întâi modulul tău PlayerData și orice script de leaderstats prin Search Scripts și Read Script, ca să adauge câmpuri în datele tale existente, nu să scrie un al doilea script de salvare
  • Poate face o schiță a ecranului prin layout-ul HUD din Build UI (cu pluginul 3.9 sau mai nou, în stil de simulator) sau poate construi butoanele într-un LocalScript și scrie ModuleScript-ul, Script-ul de server și LocalScript-ul prin Create Script
  • Are instrucțiuni să verifice compilarea fiecărui script scris prin Check Script, care îl compilează în Studio fără să-l ruleze
  • Pune un punct de anulare înainte și după fiecare lot de modificări, așa că Ctrl+Z anulează câte un lot

RoCode nu poate crea gamepass-uri și developer products și nici nu poate încărca mesh-uri și iconițe pentru pet-uri: asta se face în Creator Hub și Studio. Cu pluginul 3.9.11 sau mai nou, RoCode poate porni un playtest al jocului tău în Studio și poate controla un personaj de test ca să verifice că totul merge, iar cu pluginul 3.9.15 sau mai nou personajul de test poate apăsa butoane de pe ecran, de exemplu poate apăsa Click și poate verifica dacă Coins a crescut. Decide singur când să pornească un playtest, până la 2 pe construcție plus 1 ca să-și verifice reparația, și verifică doar ce a ales, așa că bucla verific-o tu. Un simulator întreg înseamnă mai multe prompturi, câte un sistem odată: cum construiești cu RoCode câte un sistem pe prompt. Cum se conectează RoCode la Studio.

Întrebări frecvente

Cum faci un simulator în Roblox fără scripturi?

Un simulator funcțional are nevoie de scripturi: cineva trebuie să adauge monedele, să verifice prețurile și să salveze progresul. Poți lipi cele trei scripturi din acest ghid așa cum sunt și să schimbi doar numerele din SimulatorConfig sau să le lași pe seama unui kit din Creator Store, a unui plugin ori a unui agent AI și să verifici că monedele le decide serverul. Variante.

Cum funcționează un sistem de rebirth?

Un rebirth îți schimbă monedele și upgrade-urile pe un bonus permanent. În acest ghid primul rebirth costă 1 000 de monede; setează Coins la 0, Click Power la nivelul 1 și adaugă 1 la Rebirths, iar apoi fiecare clic se înmulțește cu Rebirths + 1. Fiecare rebirth costă de trei ori mai mult decât cel anterior.

Cum faci un simulator de forță sau de sală?

Dă-le jucătorilor un Tool, de exemplu o ganteră, al cărei LocalScript declanșează același remote Click la Tool.Activated. Serverul calculează recompensa exact la fel ca pentru un clic pe buton. Scade limita de clicuri a serverului la ritmul ridicărilor, ca un script să nu poată câștiga mai mult decât un jucător. Scriptul e în secțiunea versiunea cu ganteră.

Ce sisteme îi trebuie unui simulator?

Întâi bucla de câștig, upgrade-uri și rebirth-uri, apoi salvarea, apoi pet-uri sau altă colecție care înmulțește câștigul, zone după rebirth-uri, clasamente, recompense zilnice și coduri, iar la final de tot gamepass-uri. În ordinea de construcție e un ghid pentru fiecare.

Cât ar trebui să dureze un rebirth?

Destul de mult cât jucătorii să cumpere întâi câteva upgrade-uri și destul de puțin cât să ajungă la unul în prima sesiune. Cu numerele acestui ghid, primul rebirth vine în aproximativ 1.2 minute la 5 clicuri pe secundă; dacă ridici REBIRTH_BASE_COST la 10 000, vor fi în jur de 8 minute. Mai multe setări în tabelul de ritm.

Cum te aperi de autoclickere?

Serverul numără cel mult 15 clicuri pe jucător în fiecare fereastră de o secundă și le ignoră pe celelalte. Sub această limită un script arată la fel ca un jucător rapid, așa că economia o protejează tocmai limita. Poți vinde și autoclicul ca gamepass care rulează pe server.

De ce se resetează monedele la reintrare?

Încă nu le salvează nimic. Adaugă modulul PlayerData din tutorialul DataStore, adaugă PowerLevel și Rebirths în DEFAULTS-ul lui și setează SAVE_PROGRESS = true în SimulatorService, ca la pasul 4.

Cum adaugi pet-uri într-un simulator?

Fă din fiecare pet un multiplicator pe care serverul îl aplică clicurilor. Deschide ouăle pe server cu o alegere aleatorie ponderată, salvează id-urile pet-urilor jucătorului împreună cu restul datelor lui și arată-le într-un GUI de inventar, ca în ghidul despre inventar.

Ce e mai bine: clic pe un part sau pe un buton?

Merg amândouă. Un buton pe ecran e comod pe telefoane, iar un part cu ClickDetector se potrivește unui joc în care totul se întâmplă în lume. Conform documentației Roblox, serverul nu verifică deloc evenimentele ClickDetector, așa că limitează frecvența acestor clicuri pe server la fel.

Surse și lecturi suplimentare

Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.