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
Come funziona il ciclo principale di un simulatore
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.
| Azione | Quanto costa | Cosa dà | Chi decide |
|---|---|---|---|
| Clic | Niente | Monete pari a Click Power × (Rebirths + 1) | Il server, che conta al massimo 15 clic in ogni finestra di un secondo |
| Potenziamento | 10 monete, poi 1.5 volte il prezzo precedente per ogni livello | Un altro livello di Click Power, fino al 50 | Il server, in base alla sua copia dei prezzi |
| Rebirth | 1 000 monete, poi 3 volte il prezzo precedente per ogni rebirth | Monete di nuovo a 0 e Click Power di nuovo al livello 1, più un +1 permanente al moltiplicatore | Il 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.
| Elemento | Dove si trova | Cosa fa |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | Prezzi, limiti e formule per il valore del clic, il prezzo del potenziamento e il prezzo del rebirth. Lo leggono entrambe le parti. |
Script SimulatorService | ServerScriptService | Conserva i numeri di ogni giocatore, gestisce clic, potenziamenti e rebirth e riempie leaderstats. |
Folder SimulatorRemotes | ReplicatedStorage (lo crea SimulatorService) | Il RemoteEvent Click e le RemoteFunction BuyUpgrade e Rebirth. |
LocalScript SimulatorClient | StarterPlayerScripts | Costruisce i pulsanti, invia clic e richieste e mostra i numeri del server. |
ModuleScript PlayerData (facoltativo) | ServerScriptService | Salva i progressi tra una sessione e l'altra. Viene dal tutorial sui DataStore e serve solo per il 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.
- Nell'Explorer passa il mouse su ReplicatedStorage, clicca sul pulsante + e inserisci un ModuleScript.
- Rinominalo in
SimulatorConfig(i nomi distinguono maiuscole e minuscole) e sostituisci il suo contenuto con il codice qui sotto.
-- 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.
| Livello di Click Power | Prezzo del livello successivo | Monete per clic, senza rebirth | Monete per clic, 1 rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
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.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1 000 (questa guida) | 1.2 | 2.7 | 4.8 |
| 5 000 | 4.3 | 10.1 | 18.3 |
| 10 000 | 8.2 | 16.9 | 33.2 |
| 25 000 | 16.7 | 40.1 | 74.5 |
| 50 000 | 32.8 | 68.8 | 137.8 |
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:
-- 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.
- Nell'Explorer espandi StarterPlayer, passa il mouse su StarterPlayerScripts e inserisci un LocalScript chiamato
SimulatorClient. - Sostituisci il suo contenuto con il codice qui sotto e premi Play.
-- 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,
UIAspectRatioConstraintlo tiene quadrato eUISizeConstraintlo 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 aUNITS.- 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.
- Segui il passo 1 del tutorial sui DataStore per aggiungere il ModuleScript
PlayerDatain 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 scriptMaindel tutorial qui non serve. - In PlayerData aggiungi
PowerLevel = 1,eRebirths = 0,alla tabellaDEFAULTS, accanto aCoins = 0,. - Nello stesso modulo aggiungi
PowerLevel: number,eRebirths: number,al tipoData, così il controllo rigoroso dei tipi conosce i nuovi campi. - In SimulatorService sostituisci
local SAVE_PROGRESS = falseconlocal 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.
| L'exploiter prova a | Se decidesse il client | Cosa fa SimulatorService |
|---|---|---|
| Chiamare Click in un ciclo il più velocemente possibile | Monete infinite | Conta al massimo 15 clic in ogni finestra di un secondo e ignora gli altri. |
| Inviare un numero di monete insieme al clic | Si sceglie da solo la ricompensa | Ignora qualsiasi argomento. Il valore del clic viene dai numeri del server. |
| Comprare un potenziamento o un rebirth senza le monete necessarie | Potenziamenti gratis | Confronta il prezzo con i Coins sul server e risponde "You need N more coins." |
| Cambiare Coins in leaderstats sul proprio schermo | Spendere monete che non ha | Non legge mai leaderstats. Ci scrive soltanto, dalla propria tabella. |
| Impostare l'attributo PowerLevel sul proprio Player | Un clic più forte | Non legge mai questo attributo, e la modifica resta sul dispositivo del giocatore. |
| Chiamare Rebirth due volte nello stesso istante | Due rebirth al prezzo di uno | Ricontrolla il prezzo a ogni chiamata, e tra il controllo e la modifica niente cede l'esecuzione. |
| Cambiare i prezzi nella propria copia di SimulatorConfig | Potenziamenti più economici | Usa 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
| Trucco | Problema | Questa guida |
|---|---|---|
Un LocalScript aggiunge monete con leaderstats.Coins.Value += 1 | La modifica resta su un solo dispositivo, e il proprio dispositivo lo controlla l'exploiter | Le monete le aggiunge il server |
clickEvent:FireServer(amount) | Il client si sceglie da solo la ricompensa | Click non passa argomenti |
| Nessun limite di frequenza sul server | La documentazione di Roblox dice di non affidarsi mai solo a un limite sul client | Al massimo 15 clic in ogni finestra di un secondo |
SetAsync a ogni clic o potenziamento | Consuma il limite di scritture del server | PlayerData 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 simulatore | Due script che salvano la stessa chiave si sovrascrivono a vicenda | Scrive nella tabella di PlayerData |
Cicli while wait(1) do per il reddito passivo | Roblox indica il wait globale come deprecato, sostituito da task.wait | task.wait (vedi Come ampliarlo) |
MouseButton1Click sui pulsanti | Pensato per i clic del mouse | Activated, 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.
- Premi Play. In alto sullo schermo c'è scritto 0 coins, sul pulsante verde Upgrade: 10 e su quello arancione Rebirth: 1.0K.
- Premi dieci volte il pulsante viola Click!. Ogni clic mostra un +1 dorato, e Coins nella lista dei giocatori sale di 1.
- 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.
- Senza cliccare, premi Rebirth. La riga di stato scrive "You need 1000 more coins to rebirth.", e non cambia nulla.
- Per provare il rebirth senza 1 000 clic, ferma il test, cambia
Coins = 0inCoins = 1000nella 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. - Per vedere il limite di frequenza, metti
MAX_CLICKS_PER_SECONDin 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. - 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.
- 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.
- 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.
- Nell'Explorer passa il mouse su StarterPack, inserisci un Tool e chiamalo
Dumbbell. Inserisci al suo interno una Part chiamataHandle, dalle la forma di un manubrio e togli la spunta da Anchored, come nei passi sul Tool della guida alla spada. - Inserisci nel Tool un LocalScript chiamato
LiftCliente incolla il codice qui sotto. - Premi Play, prendi il manubrio e clicca. Le monete salgono del tuo Click Power a ogni sollevamento, esattamente come con il pulsante.
-- 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_SECONDSfrena solo i giocatori onesti: un cheater può chiamare Click dal proprio codice. Se il sollevamento è l'unico modo per guadagnare, abbassaMAX_CLICKS_PER_SECONDin 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 = falsesubito dopo la riga di SimulatorClient che creaclickButton. - 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 | Sistema | Guida | Perché proprio ora |
|---|---|---|---|
| 1 | Guadagno, potenziamento, rebirth | Questa guida | Tutto il resto moltiplica questo ciclo, quindi prima regola i suoi numeri con la tabella del ritmo. |
| 2 | Salvataggio | Tutorial sui DataStore, poi il passo 4 | Progressi che si azzerano quando rientri uccidono un simulatore. Aggiungilo prima di qualsiasi cosa che i giocatori possano perdere. |
| 3 | Uova e pet come moltiplicatori | Apertura delle uova e pet che seguono il giocatore | Un secondo obiettivo accanto alle monete: qualcosa da collezionare che rende ogni clic più prezioso. |
| 4 | Zone dietro i rebirth | Come ampliarlo | Dove andare dopo un rebirth, con ricompense migliori controllate dal server. |
| 5 | Classifiche | Guida alla classifica | Una top 10 globale per rebirth dà senso alla lunga salita. |
| 6 | Ricompense giornaliere e codici | Ricompense giornaliere e codici | Motivi per tornare domani e dopo ogni aggiornamento. |
| 7 | Game pass | Guida ai game pass | Monete 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.
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.
- 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
- Roblox Creator Docs: Securing the client-server boundary (in inglese). limite di frequenza, esempio di negozio nel gioco ed eventi ClickDetector
- Roblox Creator Docs: Security and cheat mitigation tactics (in inglese). cosa controlla un exploiter sul proprio dispositivo
- Roblox Creator Docs: Remote events and callbacks (in inglese). FireServer, il parametro del giocatore, InvokeServer e OnServerInvoke
- Roblox Creator Docs: Leaderboards (in inglese). leaderstats e archivi dati ordinati
- Roblox Creator Docs: Data store error codes and limits (in inglese). limiti di scrittura per server per archivi dati normali e ordinati
- Roblox Engine API: GuiButton (in inglese). Activated su computer, telefono e console
- Roblox Engine API: GuiService (in inglese). AutoSelectGuiEnabled e selezione degli oggetti GUI con il gamepad
- Roblox Engine API: IntValue (in inglese). intervallo a 64 bit e perdita di precisione oltre 2^53
- Roblox Creator Docs: Size modifiers and constraints (in inglese). UIAspectRatioConstraint e UISizeConstraint
- Roblox Creator Docs: Studio testing modes (in inglese). Device Simulator e Controller Emulator
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.