Tutorial · Sistemi di gioco

Come fare un simulatore su Roblox

Quasi tutti i simulatori girano sullo stesso ciclo: fai qualcosa di semplice e guadagni valuta, la spendi in potenziamenti che te ne fanno guadagnare di più, e poi fai un rebirth per ricominciare da capo con un moltiplicatore permanente. In questa guida costruiamo questo ciclo come un clicker di tre script in cui ogni numero lo decide il server, e salviamo i progressi con il modulo PlayerData del tutorial sui DataStore. Se non hai mai fatto un gioco in Studio, prima crea un breve percorso con le monete.

Aggiornato il 20 novembre 202627 min di letturaScritto da

In breve

Un simulatore su Roblox è un solo ciclo: clicca per guadagnare monete, spendile in potenziamenti che ne danno di più, poi fai un rebirth per un moltiplicatore permanente. Tieni i prezzi in un ModuleScript in ReplicatedStorage. Un solo Script in ServerScriptService conserva per ogni giocatore Coins, Click Power e Rebirths, conta al massimo 15 clic al secondo dal RemoteEvent Click e vende potenziamenti e rebirth tramite RemoteFunction dopo aver controllato il prezzo. Un LocalScript mostra i pulsanti Click, Upgrade e Rebirth. Con i numeri di questa guida un giocatore che clicca 5 volte al secondo arriva al primo rebirth in circa 1.2 minuti, e la tabella del ritmo mostra cosa cambiare per rendere la salita più lunga.

  • Il clic non invia nient'altro che il clic stesso. Quanto vale lo calcola il server, quindi un client modificato non può accreditarsi monete da solo.
  • Salva tutta la tabella a intervalli regolari e quando il giocatore esce, non a ogni clic. Roblox concede a ogni server 60 + 40 × giocatori scritture nell'archivio dati al minuto.
  • Non sai programmare? Lo stesso ciclo può costruirlo un kit del Creator Store, un plugin o un agente IA. Controlla che le monete le decida il server: le opzioni.
  • Ti serve una palestra o una miniera invece di un pulsante? Un Tool può chiamare lo stesso remote Click: la versione con il manubrio. Poi aggiungi i sistemi seguendo l'ordine di costruzione più sotto.
In questa pagina
  1. Come funziona
  2. 1. Modulo delle impostazioni
  3. 2. Script del server
  4. 3. Pulsanti
  5. 4. Salvataggio
  6. Perché decide il server
  7. 5. Prova
  8. Versione con il manubrio
  9. Ordine di costruzione
  10. Senza scripting
  11. Come ampliarlo
  12. Il genere
  13. Common errors
  14. Con RoCode
  15. Domande frequenti
  16. Fonti e letture

Come funziona il ciclo principale di un simulatore

IllustrazioneIl giocatore compra il livello 2 di Click Power per 10 monete, poi (accelerato) accumula 1 000 monete e fa un rebirth: monete e potenziamenti si azzerano, e ogni clic vale x2.

Un simulatore è un ciclo di tre azioni. Il giocatore fa di continuo qualcosa di semplice per guadagnare valuta, la spende in potenziamenti che gliene fanno guadagnare di più, e quando i potenziamenti diventano cari fa un rebirth: cede monete e potenziamenti in cambio di un bonus che resta per sempre, e risale di nuovo, più in fretta. In altri simulatori invece di cliccare si sollevano pesi, si scava o si raccolgono oggetti, ma il ciclo sotto è lo stesso.

Le tre azioni del ciclo in questa guida
AzioneQuanto costaCosa dàChi decide
ClicNienteMonete pari a Click Power × (Rebirths + 1)Il server, che conta al massimo 15 clic in ogni finestra di un secondo
Potenziamento10 monete, poi 1.5 volte il prezzo precedente per ogni livelloUn altro livello di Click Power, fino al 50Il server, in base alla sua copia dei prezzi
Rebirth1 000 monete, poi 3 volte il prezzo precedente per ogni rebirthMonete di nuovo a 0 e Click Power di nuovo al livello 1, più un +1 permanente al moltiplicatoreIl server

Ogni numero vive sul server. Il dispositivo del giocatore disegna i pulsanti e chiede ("ho cliccato", "voglio un potenziamento"), e il server decide quanto vale e se si può fare. Gli script di clicker che vengono bucati spesso aggiungono monete in un LocalScript o lasciano che il client invii quante monete aggiungere.

Di cosa è fatto il simulatore
ElementoDove si trovaCosa fa
ModuleScript SimulatorConfigReplicatedStoragePrezzi, limiti e formule per il valore del clic, il prezzo del potenziamento e il prezzo del rebirth. Lo leggono entrambe le parti.
Script SimulatorServiceServerScriptServiceConserva i numeri di ogni giocatore, gestisce clic, potenziamenti e rebirth e riempie leaderstats.
Folder SimulatorRemotesReplicatedStorage (lo crea SimulatorService)Il RemoteEvent Click e le RemoteFunction BuyUpgrade e Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsCostruisce i pulsanti, invia clic e richieste e mostra i numeri del server.
ModuleScript PlayerData (facoltativo)ServerScriptServiceSalva i progressi tra una sessione e l'altra. Viene dal tutorial sui DataStore e serve solo per il passo 4.
L'Explorer durante il gioco. SimulatorService crea SimulatorRemotes e i tre remote all'avvio del gioco, e PlayerData compare solo dopo che aggiungi il salvataggio al passo 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

Passo 1: metti prezzi e formule in un modulo

Ogni numero che potresti voler ritoccare va in un solo ModuleScript: quanto vale un clic, quanto costano ogni potenziamento e ogni rebirth e il limite di clic. Il server decide in base a questo, e il LocalScript ne prende i prezzi per i pulsanti, quindi ogni modifica è una sola correzione in un solo posto.

  1. Nell'Explorer passa il mouse su ReplicatedStorage, clicca sul pulsante + e inserisci un ModuleScript.
  2. Rinominalo in SimulatorConfig (i nomi distinguono maiuscole e minuscole) e sostituisci il suo contenuto con il codice qui sotto.
ModuleScript in ReplicatedStorage chiamato SimulatorConfig
-- Tutti i numeri del ciclo principale e le formule usate da entrambe le parti. Il client si limita
-- a mostrare i prezzi in base a questi; il server decide in base alla propria copia.

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- prezzo del livello 2 di Click Power
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- ogni livello costa 1.5 volte il precedente
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- monete per il primo rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- ogni rebirth costa 3 volte il precedente
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- i clic oltre questo numero in un secondo vengono ignorati

-- Monete per un clic: livello di Click Power moltiplicato per 1 + numero di rebirth
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- Prezzo del prossimo livello di Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- Monete necessarie per il prossimo rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

I giocatori possono leggere un ModuleScript in ReplicatedStorage, quindi questi prezzi sono pubblici. Va bene così: sono già scritti sui pulsanti. Client e server eseguono ognuno la propria copia del modulo, quindi un giocatore che cambia i numeri sul suo dispositivo non cambia nulla sul server.

Cosa danno le formule con queste impostazioni
Livello di Click PowerPrezzo del livello successivoMonete per clic, senza rebirthMonete per clic, 1 rebirth
11012
21524
32236
43348
550510

I rebirth costano 1 000 monete, poi 3 000, poi 9 000, perché rebirthCost ogni volta moltiplica il prezzo per 3. Dopo un rebirth ogni clic vale il doppio, dopo due il triplo, e così via.

Quanto dura un rebirth con questi numeri

Le formule decidono quanto dura il ciclo, quindi conviene fare i conti prima che li facciano i giocatori. La tabella presuppone che il giocatore faccia il rebirth appena può pagarlo, e nel resto del tempo compri il livello successivo di Click Power quando può pagarlo e costa meno del rebirth. Il tempo si conta da una partenza nuova, quindi l'ultima colonna è il tempo totale fino a 3 rebirth.

Minuti da una partenza nuova a ogni rebirth a 5 clic al secondo, per REBIRTH_BASE_COST. Calcolati con le formule di SimulatorConfig, non misurati su giocatori
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1 000 (questa guida)1.22.74.8
5 0004.310.118.3
10 0008.216.933.2
25 00016.740.174.5
50 00032.868.8137.8

Senza rebirth il livello 5 di Click Power arriva dopo 34 clic, il livello 10 dopo 122 e il livello 13 dopo 285. Con i numeri predefiniti a quel punto il giocatore smette di potenziarsi, perché il livello 14 costa 1 297 monete, più del rebirth da 1 000 monete, e il primo rebirth arriva dopo 362 clic in totale. Con il limite del server di 15 clic al secondo dividi ogni tempo per 3. Se cambi un qualsiasi numero in SimulatorConfig, questi tempi cambiano con lui, quindi ricalcolali.

Regolare la crescita

I due numeri _GROWTH stabiliscono quanto in fretta salgono i prezzi. Con 1.5 ogni potenziamento costa una volta e mezza il precedente, e ogni livello aggiunge solo una moneta per clic (prima del moltiplicatore dei rebirth), quindi ogni nuovo livello si ripaga sempre più lentamente. È proprio questo rallentamento a rendere conveniente il rebirth. Alza la crescita per una salita più lunga, abbassala per una più veloce, e tieni REBIRTH_BASE_COST abbastanza alto perché i giocatori comprino qualche potenziamento prima del primo rebirth.

Perché il primo rebirth arrivi dopo qualche minuto e non dopo circa uno, alza REBIRTH_BASE_COST a 5 000 o 10 000.

Passo 2: aggiungi lo script del server

Questo Script possiede ogni numero. Crea i remote, dà a ogni giocatore una cartella leaderstats con Coins e Rebirths e risponde a tre richieste. Passa il mouse su ServerScriptService, inserisci uno Script, rinominalo in SimulatorService e sostituisci il contenuto con questo codice:

Script in ServerScriptService chiamato SimulatorService
-- Possiede ogni numero: i clic fanno guadagnare monete qui, potenziamenti e rebirth si comprano qui,
-- e leaderstats si limitano a mostrare il risultato.

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

-- false: a ogni sessione tutti ripartono da zero. true: caricamento e salvataggio con il modulo PlayerData
-- del tutorial sui DataStore (prima aggiungi PowerLevel = 1 e Rebirths = 0 ai suoi 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 } = {} -- quando è iniziata la finestra di un secondo attuale di questo giocatore
local clickCount: { [Player]: number } = {} -- clic contati in questa finestra

-- Copia i numeri del server dove i giocatori li vedono: in leaderstats e in un attributo
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

-- Avvia il giocatore con i dati ricevuti (numeri nuovi o la tabella salvata)
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

-- Il clic non porta numeri: quanto vale lo calcola il server
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 o uno script che chiama il remote in un ciclo
	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
	-- Il rebirth scambia monete e potenziamenti con un moltiplicatore permanente
	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

-- Numeri iniziali: nuovi oppure la tabella che il modulo PlayerData carica e salva
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) -- la stessa tabella che salva PlayerData, quindi ogni modifica viene salvata
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- chi aveva i dati già caricati prima dell'avvio di questo 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)

Il Click Power arriva al giocatore come attributo PowerLevel sul suo oggetto Player, non come terzo valore in leaderstats, quindi la lista dei giocatori mostra solo Coins e Rebirths. Gli attributi impostati dal server si replicano sul dispositivo del giocatore; una modifica che il giocatore fa sul suo dispositivo resta lì.

Clic e limite di frequenza

Il remote Click non passa argomenti. Sul server il primo parametro del gestore OnServerEvent è sempre il giocatore che l'ha chiamato, quindi il server sa chi ha cliccato, prende il suo livello di Click Power e i suoi Rebirths e aggiunge clickValue ai suoi Coins. Nella richiesta non c'è nulla che un cheater possa cambiare.

La guida di Roblox sulla sicurezza dice di non affidarsi mai solo a un limite di frequenza sul client, e l'accredito di valuta è tra le azioni da limitare. Il server conta i clic di ogni giocatore in finestre di un secondo: il primo clic apre la finestra, e quando sono stati contati 15 clic gli altri vengono ignorati finché non è passato un secondo dall'inizio della finestra. Uno script che chiama il remote in un ciclo ottiene al massimo 15 clic contati in ogni finestra. Per permettere di cliccare più veloce o più piano, cambia MAX_CLICKS_PER_SECOND in SimulatorConfig.

Potenziamenti e rebirth

BuyUpgrade e Rebirth sono RemoteFunction, quindi il pulsante può aspettare la risposta e mostrarla. Ogni gestore prende il prezzo dalla copia di SimulatorConfig del server, controlla i Coins del giocatore e solo dopo cambia qualcosa. Restituisce true o false e un messaggio, per esempio "You need 5 more coins.", che il LocalScript mostra nella riga di stato.

Tra il controllo del prezzo e la modifica niente aspetta né cede l'esecuzione (yield), quindi due richieste dello stesso giocatore non possono superare entrambe il controllo prima che la prima prenda le monete. Il rebirth mette Coins a 0, Click Power al livello 1 e aggiunge 1 a Rebirths, e la formula del clic trasforma questo in un moltiplicatore Rebirths + 1.

L'interruttore SAVE_PROGRESS

Con SAVE_PROGRESS = false ogni giocatore a ogni sessione parte da 0 monete, ed è quello che vuoi mentre costruisci il gioco. Il passo 4 lo attiva. A quel punto lo script aspetta che il modulo PlayerData carichi ogni giocatore e lavora direttamente sulla tabella che quel modulo salva, quindi ogni moneta e ogni rebirth vengono salvati senza codice in più.

Passo 3: costruisci i pulsanti

Questo LocalScript costruisce tutto lo schermo nel codice: il contatore delle monete in alto, un grande pulsante Click al centro, i pulsanti Upgrade e Rebirth in basso e una riga di stato per le risposte del server. Da solo non cambia mai nessun numero.

  1. Nell'Explorer espandi StarterPlayer, passa il mouse su StarterPlayerScripts e inserisci un LocalScript chiamato SimulatorClient.
  2. Sostituisci il suo contenuto con il codice qui sotto e premi Play.
LocalScript in StarterPlayerScripts chiamato SimulatorClient
-- Costruisce i pulsanti del simulatore e mostra i numeri del server. Non li cambia mai da solo.

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))
-- Il pulsante Click resta quadrato, in proporzione allo schermo e non più grande di 200 per 200,
-- così sul telefono sta tra il contatore delle monete e i pulsanti in basso
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()

-- Il "+N" che compare sopra il pulsante. Il numero è solo una stima per l'aspetto;
-- quanto vale davvero il clic lo decide il server.
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)

I pulsanti usano Activated, che Roblox attiva con un clic del tasto sinistro del mouse sul computer, con un tocco sul telefono e premendo A (o la croce) sul gamepad in modalità di navigazione della UI.

Sul gamepad A preme solo il pulsante selezionato. Quando GuiService.AutoSelectGuiEnabled è attivo, il tasto Select del gamepad seleziona i tuoi pulsanti a schermo; poi i giocatori possono spostarsi tra di essi e premere A. Se vuoi che un tasto del gamepad clicchi subito, collegalo con ContextActionService e chiama da lì lo stesso remote Click.

Quattro dettagli dello script:

  • Il pulsante Click si adatta allo schermo. La sua dimensione è una frazione dello schermo, UIAspectRatioConstraint lo tiene quadrato e UISizeConstraint lo limita a 200 per 200 pixel. Su un monitor è largo 200 pixel; sul telefono si rimpicciolisce e sta tra il contatore delle monete e i pulsanti in basso. Se sposti gli elementi, tienilo lontano da loro: Rebirth non chiede conferma, quindi un tocco per sbaglio può azzerare monete e potenziamenti del giocatore.
  • Il "+N" che compare è solo estetico. Usa la copia della formula del client. Se il server ignora un clic per il limite di frequenza, il "+N" compare lo stesso, ma le monete non cambiano.
  • short() rende leggibili i numeri grandi. 1 234 viene mostrato come 1.2K, e 5 600 000 come 5.6M. La funzione arrotonda per difetto, quindi il contatore non mostra mai più di quello che hai. Per numeri oltre T (mille miliardi) aggiungi voci a UNITS.
  • Lo schermo si aggiorna con gli eventi. Ascolta i valori Coins e Rebirths e l'attributo PowerLevel, quindi i prezzi sui pulsanti sono giusti comunque cambino i numeri.

Nello ScreenGui ResetOnSpawn è impostato su false, quindi resta quando il personaggio riappare. Qui conta: un LocalScript in StarterPlayerScripts viene copiato al giocatore una volta sola, all'ingresso, quindi non ricostruirebbe lo schermo.

Passo 4: salva i progressi con PlayerData

Per ora tutto si azzera quando il giocatore esce. Invece di un secondo script di salvataggio, il simulatore si collega al modulo PlayerData del tutorial sui DataStore. Quel modulo riprova già le richieste fallite, salva automaticamente ogni 180 secondi, salva quando il giocatore esce e quando il server si spegne e non salva mai un giocatore i cui dati non si sono caricati.

  1. Segui il passo 1 del tutorial sui DataStore per aggiungere il ModuleScript PlayerData in ServerScriptService. Per provare il salvataggio in Studio, attiva l'accesso di Studio ai servizi API in una copia di prova del gioco, come spiega la sua prima sezione. SimulatorService carica il modulo da solo con require, quindi lo script Main del tutorial qui non serve.
  2. In PlayerData aggiungi PowerLevel = 1, e Rebirths = 0, alla tabella DEFAULTS, accanto a Coins = 0,.
  3. Nello stesso modulo aggiungi PowerLevel: number, e Rebirths: number, al tipo Data, così il controllo rigoroso dei tipi conosce i nuovi campi.
  4. In SimulatorService sostituisci local SAVE_PROGRESS = false con local SAVE_PROGRESS = true.

I giocatori salvati prima che aggiungessi i campi li ricevono in automatico: la funzione migrate di PlayerData riempie tutti i campi di DEFAULTS che mancano nella tabella salvata, quindi partono con Click Power al livello 1 e 0 rebirth e mantengono i loro Coins. Se salti il punto 2, SimulatorService mostra un avviso con i campi da aggiungere e non avvia il giocatore.

Perché il simulatore scrive nella tabella di PlayerData

Quando il salvataggio è attivo, SimulatorService non copia i numeri da nessuna parte. PlayerData.Get(player) restituisce la tabella viva che il modulo salva, e il simulatore cambia Coins, PowerLevel e Rebirths in quella stessa tabella. Ogni numero ha una sola copia, e nell'archivio dati scrive un solo script. Due script che salvano la stessa chiave si sovrascrivono a vicenda, e uno dei due può salvare numeri vecchi sopra i numeri dell'altro.

Non creare anche leaderstats nel gestore Loaded, come il tutorial sui DataStore consiglia per altri giochi: SimulatorService crea già Coins e Rebirths dalla tabella caricata. Se leaderstats li crea già uno script della classifica, eliminalo.

Perché non salvare a ogni clic

Roblox concede a ogni server 60 + 40 × giocatori scritture al minuto in un normale archivio dati (il resto è nella tabella dei limiti del tutorial sui DataStore). Salvare a ogni clic con 15 clic al secondo significa 900 scritture al minuto per un solo giocatore, molto più delle 100 che riceve un server con un giocatore. Salvare tutta la tabella ogni 180 secondi, quando il giocatore esce e quando il server si spegne costa solo poche scritture per giocatore, e in caso di crash si perdono al massimo i progressi dall'ultimo salvataggio automatico.

Se il caricamento non riesce, il modulo lascia giocare il giocatore con numeri nuovi ma non li salva mai, quindi un caricamento sbagliato non può cancellare i progressi veri. Il tutorial spiega come il modulo gestisce questo caso.

Perché ogni numero lo decide il server

Gli exploiter controllano il proprio dispositivo. La guida di Roblox sulla sicurezza dice che possono cambiare qualsiasi cosa nella loro copia locale del gioco e chiamare qualsiasi RemoteEvent o RemoteFunction tutte le volte che vogliono con qualsiasi argomento. L'economia di un simulatore è protetta esattamente quanto il suo script del server.

Cosa può provare un exploiter e cosa fa SimulatorService
L'exploiter prova aSe decidesse il clientCosa fa SimulatorService
Chiamare Click in un ciclo il più velocemente possibileMonete infiniteConta al massimo 15 clic in ogni finestra di un secondo e ignora gli altri.
Inviare un numero di monete insieme al clicSi sceglie da solo la ricompensaIgnora qualsiasi argomento. Il valore del clic viene dai numeri del server.
Comprare un potenziamento o un rebirth senza le monete necessariePotenziamenti gratisConfronta il prezzo con i Coins sul server e risponde "You need N more coins."
Cambiare Coins in leaderstats sul proprio schermoSpendere monete che non haNon legge mai leaderstats. Ci scrive soltanto, dalla propria tabella.
Impostare l'attributo PowerLevel sul proprio PlayerUn clic più forteNon legge mai questo attributo, e la modifica resta sul dispositivo del giocatore.
Chiamare Rebirth due volte nello stesso istanteDue rebirth al prezzo di unoRicontrolla il prezzo a ogni chiamata, e tra il controllo e la modifica niente cede l'esecuzione.
Cambiare i prezzi nella propria copia di SimulatorConfigPotenziamenti più economiciUsa la propria copia del modulo.

La regola vale per ogni remote del simulatore: invia quello che il giocatore vuole fare, non quanto vale. La guida ai RemoteEvent spiega più nel dettaglio il controllo degli argomenti dei remote.

Cosa evitare negli script di clicker copiati

Trucchi comuni dei vecchi tutorial sui clicker e cosa fa invece questa guida
TruccoProblemaQuesta guida
Un LocalScript aggiunge monete con leaderstats.Coins.Value += 1La modifica resta su un solo dispositivo, e il proprio dispositivo lo controlla l'exploiterLe monete le aggiunge il server
clickEvent:FireServer(amount)Il client si sceglie da solo la ricompensaClick non passa argomenti
Nessun limite di frequenza sul serverLa documentazione di Roblox dice di non affidarsi mai solo a un limite sul clientAl massimo 15 clic in ogni finestra di un secondo
SetAsync a ogni clic o potenziamentoConsuma il limite di scritture del serverPlayerData salva ogni 180 secondi, all'uscita e allo spegnimento. Salva subito con PlayerData.SaveNow solo dopo qualcosa che non si può perdere, per esempio un acquisto con Robux.
Un secondo script dell'archivio dati solo per il simulatoreDue script che salvano la stessa chiave si sovrascrivono a vicendaScrive nella tabella di PlayerData
Cicli while wait(1) do per il reddito passivoRoblox indica il wait globale come deprecato, sostituito da task.waittask.wait (vedi Come ampliarlo)
MouseButton1Click sui pulsantiPensato per i clic del mouseActivated, per mouse, tocco e gamepad

Passo 5: provalo

Esegui i punti da 1 a 8 con SAVE_PROGRESS = false in SimulatorService, così ogni playtest parte con numeri nuovi. Se hai già attivato il salvataggio al passo 4, per ora mettilo a false, e per il punto 9 rimettilo a true.

  1. Premi Play. In alto sullo schermo c'è scritto 0 coins, sul pulsante verde Upgrade: 10 e su quello arancione Rebirth: 1.0K.
  2. Premi dieci volte il pulsante viola Click!. Ogni clic mostra un +1 dorato, e Coins nella lista dei giocatori sale di 1.
  3. Premi Upgrade. Le monete tornano a 0, la riga di stato diventa verde con il testo "Click Power is now level 2.", e sul pulsante ora c'è Upgrade: 15. Da qui in poi ogni clic dà 2 monete.
  4. Senza cliccare, premi Rebirth. La riga di stato scrive "You need 1000 more coins to rebirth.", e non cambia nulla.
  5. Per provare il rebirth senza 1 000 clic, ferma il test, cambia Coins = 0 in Coins = 1000 nella riga verso la fine di SimulatorService che avvia i nuovi giocatori, e premi Play. Premi Rebirth: Coins diventa 0, Rebirths nella lista dei giocatori diventa 1, la riga di stato scrive "Rebirth 1! Every click is now worth x2.", e sul pulsante ora c'è Rebirth: 3.0K. Ogni clic ora dà 2 monete al livello 1 di Click Power. Poi rimetti la riga a 0.
  6. Per vedere il limite di frequenza, metti MAX_CLICKS_PER_SECOND in SimulatorConfig a 2 e clicca velocemente. I "+N" continuano a comparire, ma i Coins salgono al massimo del valore di 2 clic al secondo. Rimetti 15.
  7. Scegli un telefono nel Device Simulator di Studio (è una beta di Studio; va bene anche il vecchio Device Emulator) e premi Play. Controlla che il pulsante Click non copra né il contatore delle monete né i pulsanti Upgrade e Rebirth, e che la riga di stato, quando premi Upgrade, sia visibile e non coperta dal pulsante.
  8. Collega un gamepad o apri il Controller Emulator di Studio (Controller nella scheda Emulation) durante il playtest, premi Select e controlla che i tre pulsanti si possano raggiungere e premere con A.
  9. Con il salvataggio attivo (passo 4) e di nuovo SAVE_PROGRESS = true, guadagna qualche moneta, premi Stop, poi di nuovo Play. I tuoi Coins, il livello di Click Power e i Rebirths tornano.

Fai un simulatore di palestra o di miniera

Molti simulatori sostituiscono il pulsante con un'azione nel mondo: sollevare un manubrio, dare un colpo di piccone, menare un fendente con una spada a vuoto. Sotto c'è lo stesso clic. Un Tool può chiamare lo stesso remote Click, quindi SimulatorService, i suoi prezzi e il suo limite di frequenza restano come sono.

  1. Nell'Explorer passa il mouse su StarterPack, inserisci un Tool e chiamalo Dumbbell. Inserisci al suo interno una Part chiamata Handle, dalle la forma di un manubrio e togli la spunta da Anchored, come nei passi sul Tool della guida alla spada.
  2. Inserisci nel Tool un LocalScript chiamato LiftClient e incolla il codice qui sotto.
  3. Premi Play, prendi il manubrio e clicca. Le monete salgono del tuo Click Power a ogni sollevamento, esattamente come con il pulsante.
LocalScript in il Tool Dumbbell in StarterPack chiamato LiftClient
-- LocalScript dentro il Tool Dumbbell, chiamato LiftClient.
-- Ogni sollevamento è un clic: chiama lo stesso remote Click del pulsante, e il server
-- decide quanto vale e quanti sollevamenti contare.

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 -- tempo tra un sollevamento e l'altro su questo dispositivo; il server ha il suo limite
local LIFT_ANIMATION_ID = "" -- facoltativo: "rbxassetid://" seguito dall'id della tua animazione

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

-- Carichiamo l'animazione di sollevamento una volta per personaggio, tramite l'Animator che Roblox mette nello 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() -- senza argomenti: la ricompensa la calcola il server
end)

Per l'animazione di sollevamento creala nell'Animation Editor con priorità Action, pubblicala e incolla il suo ID in LIFT_ANIMATION_ID. I passi sull'animazione della guida alla spada funzionano allo stesso modo.

  • Adatta il limite del server all'azione. LIFT_SECONDS frena solo i giocatori onesti: un cheater può chiamare Click dal proprio codice. Se il sollevamento è l'unico modo per guadagnare, abbassa MAX_CLICKS_PER_SECOND in SimulatorConfig al ritmo reale, per esempio a 2 per un sollevamento ogni 0.5 secondi, così uno script non può guadagnare più di un giocatore. Poi ricalcola la tabella del ritmo: ogni tempo lì è calcolato su 5 clic al secondo.
  • Tieni o nascondi il pulsante. Il pulsante Click continua a funzionare accanto al Tool. Per nasconderlo, aggiungi clickButton.Visible = false subito dopo la riga di SimulatorClient che crea clickButton.
  • Guadagni solo nel posto giusto. Per pagare solo in palestra o in miniera, controlla sul server dove si trova il personaggio prima di contare il clic, per esempio con la distanza da una parte in quella zona. Un controllo in LiftClient non fermerebbe nessuno.

Cosa fare dopo: l'ordine di costruzione di un simulatore

Un simulatore è una pila di sistemi sopra questo ciclo. Costruiscili in questo ordine, così ognuno ha qualcosa da moltiplicare, e fai un playtest dopo ognuno. Ecco l'ordine che consigliamo, con una guida per ogni passo.

Ordine di costruzione di un simulatore su Roblox, dal ciclo principale verso l'esterno
OrdineSistemaGuidaPerché proprio ora
1Guadagno, potenziamento, rebirthQuesta guidaTutto il resto moltiplica questo ciclo, quindi prima regola i suoi numeri con la tabella del ritmo.
2SalvataggioTutorial sui DataStore, poi il passo 4Progressi che si azzerano quando rientri uccidono un simulatore. Aggiungilo prima di qualsiasi cosa che i giocatori possano perdere.
3Uova e pet come moltiplicatoriApertura delle uova e pet che seguono il giocatoreUn secondo obiettivo accanto alle monete: qualcosa da collezionare che rende ogni clic più prezioso.
4Zone dietro i rebirthCome ampliarloDove andare dopo un rebirth, con ricompense migliori controllate dal server.
5ClassificheGuida alla classificaUna top 10 globale per rebirth dà senso alla lunga salita.
6Ricompense giornaliere e codiciRicompense giornaliere e codiciMotivi per tornare domani e dopo ogni aggiornamento.
7Game passGuida ai game passMonete 2x, autoclick o uno slot in più per i pet, con controllo sul server. Vendili quando il ciclo gratuito è già divertente.

Per gli schermi, i kit UI per Roblox gratuiti includono schermate in stile simulatore insieme agli script che le fanno funzionare.

Come fare un simulatore senza scrivere script

Un simulatore ha comunque bisogno di script: qualcuno deve aggiungere monete, controllare i prezzi e salvare. Scriverli tu non è obbligatorio:

  • Un kit per simulatori del Creator Store. Leggi i suoi script prima di pubblicare e controlla che le monete cambino solo in uno Script del server, non in un LocalScript.
  • Un plugin generatore di simulatori. Lo stesso controllo per tutto ciò che crea.
  • Un agente IA in Studio, per esempio RoCode, che può costruire questi stessi tre script nel place che hai aperto.
  • Build nell'app mobile di Roblox. Secondo la documentazione di Roblox, crea da una descrizione giochi 2D e 2.5D più semplici, per esempio i clicker, e arriva gradualmente nelle varie regioni.

Qualunque cosa tu scelga, fai sul risultato i controlli del passo 5 e i controlli contro gli exploit della sezione Perché ogni numero lo decide il server.

Come ampliarlo: pet, zone, autoclick e classifiche

Pet come moltiplicatori

Una variante comune: ogni pet è un moltiplicatore. Conserva la lista degli id dei pet del giocatore nella sua tabella salvata, e fai moltiplicare al server clickValue per il bonus di ogni pet equipaggiato. Apri le uova sul server: il client chiede di aprire un uovo, il server controlla e prende il prezzo, poi sceglie il pet con un'estrazione casuale pesata. Non lasciare mai che sia il client a fare l'estrazione per un uovo o a dire quale pet è uscito. La guida all'inventario mostra come conservare, salvare e mostrare gli oggetti di un giocatore, e i pet funzionano allo stesso modo. La guida all'apertura delle uova costruisce l'estrazione sul server, e la guida ai pet fa volare i pet accanto al loro proprietario.

Zone che si sbloccano con i rebirth

Una zona è una parte della mappa con ricompense migliori dietro una barriera. Blocca la ricompensa, non solo la porta: tutto ciò che paga dentro la zona deve controllare i Rebirths del giocatore nella tabella del server prima di pagare. Una porta che un LocalScript apre ai giocatori idonei va bene per l'aspetto, ma gli exploiter possono cambiare le parti e spostare il proprio personaggio sul proprio dispositivo.

Autoclick come game pass

Un autoclicker venduto come game pass deve girare sul server. Sposta il corpo del gestore di Click in una funzione, per esempio addClick(player), collega il remote a quella funzione, e per chi possiede il pass chiamala da un ciclo sul server con task.wait(0.5), non con il wait deprecato. Così gli autoclick rientrano nello stesso limite al secondo dei clic normali. Controlla il possesso sul server con MarketplaceService:UserOwnsGamePassAsync, come fa la guida ai game pass per i suoi bonus. Un pass di monete 2x funziona allo stesso modo: moltiplica clickValue sul server per chi lo possiede. Prima di fissare un prezzo, il calcolatore della tassa sui Robux gratuito mostra quanto ti frutta ogni vendita dopo la quota di Roblox, e il calcolatore DevEx mostra quanto valgono quei Robux in dollari USA.

Top 10 globale per rebirth

leaderstats confronta solo i giocatori dello stesso server. Per classificare i Rebirths di tutti i giocatori, scrivili in un archivio dati ordinato (ordered data store) e rileggi le voci in cima, come nel passo 4 della guida alla classifica. Gli archivi ordinati permettono meno scritture di quelli normali, 30 + 5 × giocatori al minuto per server, quindi scrivi quando il giocatore esce e a intervalli regolari.

Numeri molto grandi

I numeri in Luau sono double e conservano circa 15 cifre significative. IntValue conserva numeri interi fino a circa 9.2 miliardi di miliardi, ma Roblox avverte che i valori oltre 2^53 (circa 9 milioni di miliardi) perdono precisione negli script. Con queste impostazioni il prezzo del rebirth supera quella soglia al 29esimo rebirth. Se il tuo gioco va oltre, passa i valori di leaderstats a NumberValue (sostituisci IntValue in entrambi gli script), che conserva numeri molto più grandi con la stessa precisione di circa 15 cifre, e aggiungi suffissi a short().

Cosa regge un gioco simulatore

Un simulatore è un gioco di numeri. Il clic, il potenziamento e il rebirth qui sopra sono tutto il ciclo; se i giocatori restano lo decide il modo in cui crescono quei numeri. Ogni pochi minuti il giocatore deve potersi permettere qualcosa che renda più veloci i minuti successivi, e ogni sessione deve finire vicino a un obiettivo per cui viene voglia di tornare.

  • Una crescita che dura a lungo. I prezzi dei potenziamenti crescono più del guadagno, quindi ogni gradino richiede un po' più di tempo. Il rebirth azzera le monete in cambio di un moltiplicatore permanente, la vecchia zona diventa veloce e la salita sembra nuova.
  • Cose da collezionare. Zone da sbloccare, pet dalle uova che moltiplicano il guadagno e strumenti da potenziare danno ai giocatori una lista di obiettivi oltre a un solo numero.
  • Numeri grandi che restano leggibili. Mostra 1.5M, non 1500000, e conserva i numeri in modo che il server possa confrontarli anche quando diventano grandi.

Monetizzazione adatta a un simulatore

I pass più comuni moltiplicano le monete, danno uno slot in più per i pet, aprono più uova alla volta o attivano l'autoclick. Vendili come game pass e controllali sul server. I pacchetti di monete sono developer product. Se uova o qualsiasi cosa con un risultato casuale si possono comprare con Robux o con una valuta comprata con Robux, Roblox richiede di mostrare le probabilità prima dell'acquisto: leggi paid random items (in inglese) prima di costruire il negozio.

Cosa fa tornare i giocatori

Progressi salvati, una nuova zona o una serie di pet negli aggiornamenti, ricompense giornaliere, codici annunciati insieme agli aggiornamenti e una classifica dei rebirth. Altri generi, ognuno con il suo ciclo, i suoi sistemi e il suo piano di costruzione: generi di giochi su Roblox.

Errori comuni e soluzioni

Apri la finestra Output (menu Window, poi Output) prima di premere Play. La maggior parte dei problemi lì mostra un avviso o un errore con il nome dello script e la riga.

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

Il LocalScript aspetta i remote che SimulatorService crea all'avvio. Controlla che SimulatorService sia uno Script, non un LocalScript, che si trovi in ServerScriptService e che nell'Output non ci sia un suo errore. Lo stesso avviso per SimulatorConfig significa che il modulo non è in ReplicatedStorage o ha un altro nome.

I pulsanti non compaiono mai

Il LocalScript aspetta i tuoi leaderstats prima di costruire lo schermo. Se nell'Output c'è scritto Infinite yield possible su leaderstats, SimulatorService non ti ha ancora avviato. Con SAVE_PROGRESS = true aspetta PlayerData, quindi controlla che PlayerData sia in ServerScriptService e si carichi senza errori.

Nell'Output c'è scritto "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"

Il salvataggio è attivo, ma nel modulo PlayerData non ci sono ancora i nuovi campi. Aggiungili ai suoi DEFAULTS come nel passo 4 e premi di nuovo Play.

I "+1" compaiono, ma le monete non salgono

Il server non conta i clic. O c'è un errore in SimulatorService (cerca il suo testo rosso nell'Output), o i clic arrivano più velocemente di quanto permette MAX_CLICKS_PER_SECOND. Se i giocatori arrivano al limite giocando normalmente, alzalo in SimulatorConfig.

La riga di stato scrive "No answer from the server. Try again."

La chiamata a BuyUpgrade o Rebirth è fallita invece di restituire una risposta. Di solito la causa è un errore dentro SimulatorService durante la gestione della richiesta, quindi cerca il suo errore rosso nell'Output: lì è indicata la riga.

Il contatore delle monete sullo schermo e la lista dei giocatori mostrano numeri diversi

Un altro script crea anche lui una cartella leaderstats, quindi ogni giocatore ne ha due, e il LocalScript può leggere l'altra. Elimina lo script in più: SimulatorService crea da solo Coins e Rebirths.

Le monete si azzerano a ogni rientro

Il salvataggio è spento. Segui il passo 4. Se è acceso e in Studio le monete si azzerano comunque, controlla che nella copia di prova sia attivo l'accesso di Studio ai servizi API, come spiega il tutorial sui DataStore.

Fallo con RoCode

Se non hai voglia di incollarlo a mano, RoCode può costruirlo nel place che hai aperto. È un agente IA indipendente per il codice, non di Roblox: descrivi il sistema nella sua chat web, e il suo plugin per Roblox Studio crea gli script nel tuo Explorer, quindi non devi copiare codice dalla finestra della chat.

Tu scrivi

Crea un simulatore clicker: un grande pulsante Click che dà monete pari al mio livello di Click Power moltiplicato per (rebirth + 1), un pulsante Upgrade che costa 10 monete e rincara di 1.5 volte a ogni livello, e un pulsante Rebirth da 1 000 monete che azzera monete e potenziamenti. Tieni i numeri sul server e limita i clic a 15 al secondo. Ho già un modulo PlayerData.

RoCode fa
  • Può prima leggere il tuo modulo PlayerData e qualsiasi script leaderstats con Search Scripts e Read Script, per aggiungere i campi ai tuoi dati esistenti invece di scrivere un secondo script di salvataggio
  • Può preparare lo schermo con il layout HUD di Build UI (con il plugin 3.9 o più recente, in stile simulatore) oppure costruire i pulsanti in un LocalScript, e scrive il ModuleScript, lo Script del server e il LocalScript con Create Script
  • Ha l'istruzione di verificare che ogni script scritto compili con Check Script, che lo compila in Studio senza eseguirlo
  • Mette un punto di annullamento prima e dopo ogni gruppo di modifiche, quindi Ctrl+Z annulla un gruppo alla volta

RoCode non può creare game pass e developer product né caricare mesh e icone dei pet: queste cose si fanno nel Creator Hub e in Studio. Con il plugin 3.9.11 o più recente RoCode può avviare un playtest del tuo gioco in Studio e controllare un personaggio di prova per verificare che tutto funzioni, e con il plugin 3.9.15 o più recente il personaggio di prova può premere i pulsanti a schermo, per esempio premere Click e controllare che i Coins siano saliti. Decide da solo quando avviare un playtest, fino a 2 per costruzione più 1 per verificare la propria correzione, e controlla solo quello che ha scelto, quindi il ciclo controllalo tu. Un simulatore intero richiede diversi prompt, un sistema alla volta: come costruire con RoCode un sistema per prompt. Come RoCode si collega a Studio.

Domande frequenti

Come si fa un simulatore su Roblox senza script?

Un simulatore che funziona ha bisogno di script: qualcuno deve aggiungere monete, controllare i prezzi e salvare i progressi. Puoi incollare così come sono i tre script di questa guida e cambiare solo i numeri in SimulatorConfig, oppure farli creare a un kit del Creator Store, a un plugin o a un agente IA e controllare che le monete le decida il server. Le opzioni.

Come funziona un sistema di rebirth?

Il rebirth scambia le tue monete e i tuoi potenziamenti con un bonus permanente. In questa guida il primo rebirth costa 1 000 monete; mette Coins a 0, Click Power al livello 1 e aggiunge 1 a Rebirths, e da lì ogni clic viene moltiplicato per Rebirths + 1. Ogni rebirth costa il triplo del precedente.

Come si fa un simulatore di forza o di palestra?

Dai ai giocatori un Tool, per esempio un manubrio, il cui LocalScript chiama lo stesso remote Click con Tool.Activated. Il server calcola la ricompensa esattamente come per un clic sul pulsante. Abbassa il limite di clic del server al ritmo dei sollevamenti, così uno script non può guadagnare più di un giocatore. Lo script è nella sezione versione con il manubrio.

Quali sistemi servono in un simulatore?

Prima il ciclo di guadagno, potenziamenti e rebirth, poi il salvataggio, poi pet o un'altra collezione che moltiplica il guadagno, zone dietro i rebirth, classifiche, ricompense giornaliere e codici, e per ultimi i game pass. Nell'ordine di costruzione c'è una guida per ognuno.

Quanto deve durare un rebirth?

Abbastanza a lungo perché i giocatori comprino prima qualche potenziamento, e abbastanza poco da arrivarci nella prima sessione. Con i numeri di questa guida il primo rebirth arriva dopo circa 1.2 minuti a 5 clic al secondo; se alzi REBIRTH_BASE_COST a 10 000, saranno circa 8 minuti. Altre impostazioni nella tabella del ritmo.

Come ci si protegge dagli autoclicker?

Il server conta al massimo 15 clic per giocatore in ogni finestra di un secondo e ignora gli altri. Sotto questo limite uno script sembra uguale a un giocatore veloce, quindi è proprio il limite a proteggere l'economia. Puoi anche vendere l'autoclick come game pass che gira sul server.

Perché le monete si azzerano quando rientro?

Per ora non le salva niente. Aggiungi il modulo PlayerData del tutorial sui DataStore, aggiungi PowerLevel e Rebirths ai suoi DEFAULTS e metti SAVE_PROGRESS = true in SimulatorService, come nel passo 4.

Come si aggiungono i pet a un simulatore?

Fai di ogni pet un moltiplicatore che il server applica ai clic. Apri le uova sul server con una scelta casuale pesata, salva gli id dei pet del giocatore insieme al resto dei suoi dati e mostrali in una GUI dell'inventario, come nella guida all'inventario.

Meglio cliccare su una parte o su un pulsante?

Vanno bene entrambi. Un pulsante a schermo è comodo sui telefoni, e una parte con un ClickDetector si adatta a un gioco in cui tutto succede nel mondo. Secondo la documentazione di Roblox il server non controlla affatto gli eventi ClickDetector, quindi limita la frequenza di quei clic sul server allo stesso modo.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.