Resumo
Um simulador no Roblox é um loop só: clicar para ganhar moedas, gastar em upgrades que rendem mais rápido e depois dar rebirth por um multiplicador permanente. Guarde os preços em um ModuleScript no ReplicatedStorage. Deixe um Script no ServerScriptService cuidar das Coins, do Click Power e dos Rebirths de cada jogador, contar no máximo 15 cliques por segundo vindos de um RemoteEvent Click e vender upgrades e rebirths por RemoteFunctions depois de conferir o preço. Um LocalScript mostra os botões Click, Upgrade e Rebirth. Com os números deste guia, um jogador que clica 5 vezes por segundo chega ao primeiro rebirth em cerca de 1,2 minuto, e a tabela de ritmo mostra o que mudar para uma subida mais longa.
- Um clique não envia nada além do clique. O servidor calcula quanto ele vale, então um cliente editado não consegue se dar moedas.
- Salve a tabela inteira com um timer e quando o jogador sai, nunca a cada clique. A Roblox permite a cada servidor 60 + 40 × jogadores escritas de data store por minuto.
- Não sabe programar? Um kit da Creator Store, um plugin ou um agente de IA pode montar o mesmo loop. Confira se o servidor decide as moedas: as opções.
- Levantar peso ou minerar em vez de um botão? Uma Tool pode disparar o mesmo remote Click: a versão de levantar peso. Depois adicione sistemas na ordem de construção abaixo.
Nesta página
Como funciona o loop principal de um simulador
Um simulador é um loop de três ações. O jogador faz algo simples várias vezes para ganhar uma moeda, gasta em upgrades que fazem ganhar mais rápido e, quando os upgrades ficam caros, dá rebirth: abre mão das moedas e dos upgrades em troca de um bônus que nunca some, e depois sobe de novo mais rápido. Outros simuladores trocam o clique por levantar peso, minerar ou coletar, mas o loop por baixo é o mesmo.
| Ação | Quanto custa | O que dá | Quem decide |
|---|---|---|---|
| Click | Nada | Moedas iguais a Click Power × (Rebirths + 1) | O servidor, contando no máximo 15 cliques em cada janela de um segundo |
| Upgrade | 10 moedas, depois 1,5 vez o último preço a cada nível | Mais um nível de Click Power, até o nível 50 | O servidor, a partir da própria cópia dos preços |
| Rebirth | 1.000 moedas, depois 3 vezes o último preço a cada rebirth | Moedas de volta a 0 e Click Power de volta ao nível 1, mais um +1 permanente no multiplicador | O servidor |
Todo número fica no servidor. O dispositivo do jogador desenha os botões e pede coisas ("cliquei", "quero um upgrade"); o servidor decide quanto aquilo vale e se pode acontecer. Scripts de clicker que são explorados muitas vezes adicionam moedas em um LocalScript, ou deixam o cliente enviar quantas moedas somar.
| Peça | Onde fica | O que faz |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | Preços, limites e as fórmulas do valor de um clique, do preço do upgrade e do preço do rebirth. Os dois lados leem. |
Script SimulatorService | ServerScriptService | Guarda os números de cada jogador, cuida dos cliques, upgrades e rebirths e preenche os leaderstats. |
Folder SimulatorRemotes | ReplicatedStorage (o SimulatorService cria) | O RemoteEvent Click e as RemoteFunctions BuyUpgrade e Rebirth. |
LocalScript SimulatorClient | StarterPlayerScripts | Monta os botões, envia cliques e pedidos e mostra os números do servidor. |
ModuleScript PlayerData (opcional) | ServerScriptService | Salva o progresso entre as visitas. Ele vem do tutorial de DataStore e só é necessário no 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: Coloque os preços e as fórmulas em um módulo
Todo número que você pode querer ajustar vai em um ModuleScript: quanto vale um clique, quanto custa cada upgrade e cada rebirth, e o limite de cliques. O servidor usa o módulo para decidir, e o LocalScript usa para mostrar os preços nos botões, então uma mudança é uma edição em um lugar só.
- No Explorer, passe o mouse sobre ReplicatedStorage, clique no botão + e insira um ModuleScript.
- Renomeie para
SimulatorConfig(os nomes diferenciam maiúsculas de minúsculas) e troque o conteúdo pelo código abaixo.
-- Todos os números do loop principal, e as fórmulas que os dois lados usam. O cliente só
-- usa isto para mostrar preços; o servidor usa a própria cópia para decidir.
local SimulatorConfig = {}
SimulatorConfig.UPGRADE_BASE_COST = 10 -- preço do nível 2 de Click Power
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- cada nível custa 1,5 vez o anterior
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- moedas necessárias para o primeiro rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- cada rebirth custa 3 vezes o anterior
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- cliques acima disto em um segundo são ignorados
-- Moedas por clique: o nível de Click Power, multiplicado por 1 + o número de rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
return powerLevel * (rebirths + 1)
end
-- Preço do próximo nível de Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end
-- Moedas necessárias para o próximo rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end
return SimulatorConfig
Os jogadores conseguem ler um ModuleScript no ReplicatedStorage, então esses preços são públicos. Tudo bem: eles já aparecem nos botões. O cliente e o servidor rodam cada um a própria cópia do módulo, então um jogador que edita os números no dispositivo dele não muda nada no servidor.
| Nível de Click Power | Preço do próximo nível | Moedas por clique, sem rebirths | Moedas por clique, 1 rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
Os rebirths custam 1.000 moedas, depois 3.000, depois 9.000, porque o rebirthCost multiplica o preço por 3 a cada vez. Depois de um rebirth cada clique vale o dobro, depois de dois rebirths vale o triplo, e assim por diante.
Quanto tempo leva um rebirth com estes números
As fórmulas decidem quanto o loop dura, então vale a pena fazer as contas antes dos jogadores. A tabela supõe um jogador que dá rebirth assim que consegue pagar e, fora isso, compra o próximo nível de Click Power sempre que consegue pagar e ele custa menos que o rebirth. Os tempos contam a partir de um começo do zero, então a última coluna é o tempo total até 3 rebirths.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1.000 (este guia) | 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 |
Sem rebirths, o nível 5 de Click Power chega depois de 34 cliques, o nível 10 depois de 122 e o nível 13 depois de 285. Com os números padrão o jogador então para de comprar upgrades, porque o nível 14 custa 1.297 moedas, mais que o rebirth de 1.000 moedas, e o primeiro rebirth chega depois de 362 cliques no total. No limite do servidor de 15 cliques por segundo, divida cada tempo por 3. Mude qualquer número no SimulatorConfig e esses tempos mudam junto, então faça as contas de novo.
Ajustando o crescimento
Os dois números _GROWTH definem a velocidade com que os preços sobem. Com 1,5, cada upgrade custa metade a mais que o anterior, enquanto cada nível adiciona só uma moeda por clique (antes do multiplicador de rebirth), então cada nível novo demora mais para se pagar. Essa desaceleração é o que faz um rebirth valer a pena. Aumente o crescimento para uma subida mais longa, diminua para uma mais rápida, e deixe o REBIRTH_BASE_COST alto o bastante para os jogadores comprarem alguns upgrades antes do primeiro rebirth.
Para um primeiro rebirth depois de vários minutos em vez de cerca de um, aumente o REBIRTH_BASE_COST para 5.000 ou 10.000.
Passo 2: Adicione o script do servidor
Este Script é dono de todos os números. Ele cria os remotes, dá a cada jogador uma pasta leaderstats com Coins e Rebirths e responde aos três pedidos. Passe o mouse sobre ServerScriptService, insira um Script, renomeie para SimulatorService e troque o conteúdo por isto:
-- Dono de todos os números: os cliques rendem moedas aqui, upgrades e rebirths são comprados aqui,
-- e os leaderstats só mostram o resultado.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- false: todo mundo começa do zero a cada visita. true: carrega e salva com o módulo PlayerData
-- do tutorial de DataStore (adicione PowerLevel = 1 e Rebirths = 0 aos DEFAULTS dele antes).
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 começou a janela de um segundo atual deste jogador
local clickCount: { [Player]: number } = {} -- cliques contados nessa janela
-- Copia os números do servidor para o que os jogadores veem: leaderstats e um atributo
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
-- Começa um jogador com os dados recebidos (números do zero, ou uma tabela salva)
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
-- Um clique não leva números: o servidor calcula quanto ele vale
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 -- um auto clicker ou um script disparando o remote em loop
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
-- Um rebirth troca moedas e upgrades por um multiplicador 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
-- Números iniciais: do zero, ou a tabela que o módulo PlayerData carrega 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) -- a mesma tabela que o PlayerData salva, então toda mudança é salva
end
PlayerData.Loaded:Connect(onLoaded)
for _, player in Players:GetPlayers() do
onLoaded(player) -- quem teve os dados carregados antes de este script começar
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)
O Click Power chega ao jogador como um atributo PowerLevel no objeto Player dele, não como um terceiro valor de leaderstats, então a lista de jogadores mostra só Coins e Rebirths. Atributos que o servidor define replicam para o dispositivo do jogador; uma mudança que o jogador faz no próprio dispositivo fica lá.
Cliques e o limite de frequência
O remote Click não leva argumentos. No servidor, o primeiro parâmetro de um handler de OnServerEvent é sempre o jogador que disparou, então o servidor sabe quem clicou, busca o nível de Click Power e os Rebirths dele e soma o clickValue às Coins. Não há nada no pedido que um trapaceiro possa mudar.
O guia de segurança da Roblox diz para nunca depender só de um limite de frequência no cliente, e coloca dar moeda entre as ações que devem ser limitadas. O servidor conta os cliques de cada jogador em janelas de um segundo: o primeiro clique começa uma janela e, quando 15 cliques são contados, os outros são ignorados até passar um segundo desde o começo da janela. Um script que dispara o remote em loop não consegue mais que 15 cliques contados em cada janela. Para permitir cliques mais rápidos ou mais lentos, mude o MAX_CLICKS_PER_SECOND no SimulatorConfig.
Upgrades e rebirths
BuyUpgrade e Rebirth são RemoteFunctions, então o botão pode esperar a resposta e mostrá-la. Cada handler lê o preço da cópia do SimulatorConfig do servidor, confere as Coins do jogador e só então muda alguma coisa. Ele devolve true ou false e uma mensagem como "You need 5 more coins.", que o LocalScript mostra em uma linha de status.
Nada entre a checagem do preço e a mudança espera ou faz yield, então dois pedidos do mesmo jogador não conseguem passar os dois pela checagem antes de o primeiro tirar as moedas. Um rebirth define Coins como 0 e Click Power como nível 1 e soma 1 a Rebirths, que a fórmula do clique transforma em um multiplicador de Rebirths + 1.
A chave SAVE_PROGRESS
Com SAVE_PROGRESS = false, todo jogador começa com 0 moedas a cada visita, que é o que você quer enquanto monta o jogo. O Passo 4 liga a chave. O script então espera o módulo PlayerData carregar cada jogador e trabalha direto na tabela que esse módulo salva, então cada moeda e cada rebirth são salvos sem código extra.
Passo 3: Monte os botões
Este LocalScript monta a tela inteira em código: o contador de moedas no topo, um botão Click grande no meio, os botões Upgrade e Rebirth embaixo e uma linha de status para as respostas do servidor. Ele nunca muda um número sozinho.
- No Explorer, expanda StarterPlayer, passe o mouse sobre StarterPlayerScripts e insira um LocalScript chamado
SimulatorClient. - Troque o conteúdo pelo código abaixo e aperte Play.
-- Monta os botões do simulador e mostra os números do servidor. Nunca muda esses números.
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))
-- Mantém o botão Click quadrado, do tamanho da tela e nunca maior que 200 por 200,
-- para que no celular ele caiba entre o contador de moedas e os botões de baixo
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()
-- Um "+N" que sobe flutuando do botão. O número é um palpite só para mostrar;
-- o servidor decide quanto o clique vale de verdade.
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)
Os botões usam Activated, que a Roblox dispara para um clique esquerdo no computador, um toque no celular e A (ou X no PlayStation) em um controle no modo de navegação de UI.
Em um controle, o A só aperta um botão que está selecionado. Com GuiService.AutoSelectGuiEnabled ligado, o botão Select do controle seleciona os seus botões na tela; o jogador pode então andar entre eles e apertar A. Se você prefere que um botão do controle clique na hora, associe um com o ContextActionService e dispare o mesmo remote Click a partir dele.
Quatro detalhes do script:
- O botão Click acompanha o tamanho da tela. O tamanho dele é uma fração da tela, um
UIAspectRatioConstrainto mantém quadrado e umUISizeConstrainto limita a 200 por 200 pixels. Em um monitor ele tem 200 pixels de largura; no celular ele encolhe para caber entre o contador de moedas e os botões de baixo. Deixe ele longe desses botões se você mudar as coisas de lugar: o Rebirth não pede confirmação, então um toque errado ali pode zerar as moedas e os upgrades do jogador. - O "+N" é só para mostrar. Ele usa a cópia da fórmula do cliente. Se o servidor ignora um clique por causa do limite de frequência, o número ainda aparece, mas as moedas não mudam.
- O
short()deixa números grandes legíveis. 1.234 aparece como 1.2K e 5.600.000 como 5.6M. Ele arredonda para baixo, então o contador nunca mostra mais do que você tem. Adicione entradas aUNITSpara números acima de T (trilhões). - A tela se atualiza por eventos. Ela escuta os valores Coins e Rebirths e o atributo PowerLevel, então os preços dos botões ficam certos seja qual for o jeito que os números mudam.
A ScreenGui tem o ResetOnSpawn como false, então ela continua quando o personagem renasce. Isso importa aqui: um LocalScript no StarterPlayerScripts é copiado para o jogador uma vez, quando ele entra, então ele não montaria a tela de novo.
Passo 4: Salve o progresso com o PlayerData
Até aqui tudo zera quando um jogador sai. Em vez de adicionar um segundo script de salvamento, o simulador se conecta ao módulo PlayerData do tutorial de DataStore. Esse módulo já tenta de novo pedidos que falham, salva sozinho a cada 180 segundos, salva quando um jogador sai e quando o servidor desliga, e nunca salva um jogador cujos dados não carregaram.
- Siga o Passo 1 do tutorial de DataStore para adicionar o ModuleScript
PlayerDataao ServerScriptService. Para testar o salvamento no Studio, ligue o acesso do Studio aos serviços de API em uma cópia de teste do seu jogo, como explica a primeira seção dele. O SimulatorService faz o require do módulo sozinho, então você não precisa do scriptMaindo tutorial para isto. - No PlayerData, adicione
PowerLevel = 1,eRebirths = 0,dentro da tabelaDEFAULTS, ao lado deCoins = 0,. - No mesmo módulo, adicione
PowerLevel: number,eRebirths: number,ao tipoData, para a checagem estrita de tipos conhecer os campos novos. - No SimulatorService, troque
local SAVE_PROGRESS = falseporlocal SAVE_PROGRESS = true.
Jogadores que salvaram antes de você adicionar os campos recebem esses campos automaticamente: a função migrate do PlayerData preenche qualquer campo dos DEFAULTS que falte em uma tabela salva, então eles começam no nível 1 de Click Power e com 0 rebirths e mantêm as Coins. Se você pular o passo 2, o SimulatorService mostra um aviso dizendo quais campos adicionar e não prepara o jogador.
Por que o simulador escreve na tabela do PlayerData
Com o salvamento ligado, o SimulatorService não copia os números para lugar nenhum. PlayerData.Get(player) devolve a tabela viva que o módulo salva, e o simulador muda Coins, PowerLevel e Rebirths nessa mesma tabela. Existe uma cópia de cada número e um script que escreve no data store. Dois scripts salvando a mesma chave sobrescrevem um ao outro, e um deles pode salvar números mais antigos por cima dos do outro.
Não monte também leaderstats em um handler de Loaded, como o tutorial de DataStore sugere para outros jogos: o SimulatorService já cria Coins e Rebirths a partir da tabela carregada. Se um script de leaderboard já cria leaderstats, apague esse script.
Por que não salvar a cada clique
A Roblox permite a cada servidor 60 + 40 × jogadores escritas de data store padrão por minuto (a tabela de limites do tutorial de DataStore tem o resto). Salvar a cada clique a 15 cliques por segundo daria 900 escritas por minuto para um jogador, muito acima das 100 que um servidor com um jogador recebe. Salvar a tabela inteira a cada 180 segundos, quando o jogador sai e quando o servidor desliga, custa só algumas escritas por jogador, e um crash perde no máximo o progresso desde o último salvamento automático.
Se um carregamento falha, o módulo deixa o jogador jogar com números do zero, mas nunca salva esses números, então um carregamento ruim não consegue substituir o progresso real. O tutorial explica como o módulo lida com isso.
Por que o servidor decide todos os números
Exploiters controlam o próprio dispositivo. O guia de segurança da Roblox diz que eles podem mudar qualquer coisa na cópia local do jogo e disparar ou invocar qualquer RemoteEvent ou RemoteFunction quantas vezes quiserem, com quaisquer argumentos. A economia de um simulador é tão segura quanto o script de servidor dele.
| Um exploiter tenta | Se o cliente decidisse | O que o SimulatorService faz |
|---|---|---|
| Disparar o Click em loop o mais rápido possível | Moedas infinitas | Conta no máximo 15 cliques em cada janela de um segundo e ignora o resto. |
| Enviar uma quantidade de moedas junto com o clique | Ele escolhe a própria recompensa | Ignora qualquer argumento. O valor de um clique vem dos números do servidor. |
| Comprar um upgrade ou um rebirth sem moedas suficientes | Upgrades de graça | Confere o preço contra as Coins do servidor e responde "You need N more coins." |
| Editar as Coins nos leaderstats na própria tela | Gastar moedas que ele não tem | Nunca lê os leaderstats. Só escreve neles, a partir da própria tabela. |
| Definir o atributo PowerLevel no próprio Player | Um clique maior | Nunca lê o atributo, e a mudança fica no dispositivo dele. |
| Invocar o Rebirth duas vezes no mesmo instante | Dois rebirths pelo preço de um | Confere o preço de novo em cada chamada, e nada faz yield entre a checagem e a mudança. |
| Mudar os preços na própria cópia do SimulatorConfig | Upgrades mais baratos | Usa a própria cópia do módulo. |
A regra vale para todo remote de um simulador: envie o que o jogador quer fazer, nunca quanto aquilo vale. O guia de RemoteEvents cobre com mais detalhes como validar os argumentos de um remote.
Padrões a evitar em scripts de clicker copiados
| Padrão | O problema | Este guia |
|---|---|---|
Um LocalScript adiciona moedas com leaderstats.Coins.Value += 1 | A mudança fica naquele único dispositivo, e exploiters controlam o dispositivo deles | O servidor adiciona as moedas |
clickEvent:FireServer(amount) | O cliente escolhe a própria recompensa | O Click não envia argumentos |
| Nenhum limite de frequência no servidor | A documentação da Roblox diz para nunca depender só de um limite no cliente | No máximo 15 cliques em cada janela de um segundo |
SetAsync a cada clique ou upgrade | Gasta o orçamento de escritas por servidor | O PlayerData salva a cada 180 segundos, na saída e no desligamento. Salve na hora com PlayerData.SaveNow só depois de algo que não pode se perder, como uma compra com Robux. |
| Um segundo script de data store só para o simulador | Dois scripts salvando uma chave sobrescrevem um ao outro | Escreve na tabela do PlayerData |
Loops while wait(1) do para renda passiva | A Roblox marca o wait global como obsoleto, substituído pelo task.wait | task.wait (veja Indo além) |
MouseButton1Click nos botões | Documentado para cliques de mouse | Activated, para mouse, toque e controle |
Passo 5: Teste
Faça os passos 1 a 8 com SAVE_PROGRESS = false no SimulatorService, para cada teste começar com números do zero. Se você já ligou o salvamento no Passo 4, deixe como false por enquanto e volte para true no passo 9.
- Aperte Play. O topo da tela mostra 0 coins, o botão verde mostra Upgrade: 10 e o laranja mostra Rebirth: 1.0K.
- Clique dez vezes no botão roxo Click!. Cada clique mostra um +1 dourado, e Coins na lista de jogadores sobe 1.
- Aperte Upgrade. As moedas voltam para 0, a linha de status fica verde com "Click Power is now level 2." e o botão agora mostra Upgrade: 15. A partir daí cada clique dá 2 moedas.
- Antes de clicar de novo, aperte Rebirth. A linha de status diz "You need 1000 more coins to rebirth." e nada muda.
- Para testar um rebirth sem 1.000 cliques, pare o teste, troque
Coins = 0porCoins = 1000na linha perto do fim do SimulatorService que prepara jogadores novos e aperte Play. Aperte Rebirth: as moedas vão para 0, Rebirths na lista de jogadores vai para 1, a linha de status diz "Rebirth 1! Every click is now worth x2." e o botão agora mostra Rebirth: 3.0K. Cada clique agora dá 2 moedas no nível 1 de Click Power. Volte a linha para 0 depois. - Para ver o limite de frequência, defina
MAX_CLICKS_PER_SECONDcomo 2 no SimulatorConfig e clique rápido. Os números continuam aparecendo, mas as Coins sobem no máximo o valor de 2 cliques a cada segundo. Volte para 15. - Escolha um celular no Device Simulator do Studio (um beta do Studio; o Device Emulator mais antigo também funciona) e aperte Play. Confira que o botão Click não fica por cima do contador de moedas nem dos botões Upgrade e Rebirth, e que a linha de status aparece livre dele quando você aperta Upgrade.
- Conecte um controle, ou abra o Controller Emulator do Studio (Controller, na aba Emulation) durante o teste, aperte Select e confira que você consegue chegar aos três botões e apertá-los com A.
- Com o salvamento ligado (Passo 4) e
SAVE_PROGRESS = truede novo, ganhe algumas moedas, aperte Stop e depois aperte Play de novo. As suas Coins, o nível de Click Power e os Rebirths voltam.
Transforme em um simulador de levantar peso ou de mineração
Muitos simuladores trocam o botão por uma ação no mundo: levantar um haltere, bater com uma picareta, girar uma espada no ar. Por baixo é o mesmo clique. Uma Tool pode disparar o mesmo remote Click, então o SimulatorService, os preços e o limite de frequência dele continuam exatamente como estão.
- No Explorer, passe o mouse sobre StarterPack, insira uma Tool e dê o nome
Dumbbell. Insira nela uma Part chamadaHandle, dê a ela a forma de um haltere e desmarque Anchored, como nos passos da Tool do guia de espada. - Insira na Tool um LocalScript chamado
LiftCliente cole o código abaixo. - Aperte Play, equipe o haltere e clique. As Coins sobem o seu Click Power a cada levantada, exatamente como com o botão.
-- LocalScript dentro da Tool Dumbbell, chamado LiftClient.
-- Cada levantada é um clique: dispara o mesmo remote Click do botão, e o servidor
-- decide quanto vale e quantas contam.
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 entre levantadas neste dispositivo; o servidor tem o próprio limite
local LIFT_ANIMATION_ID = "" -- opcional: "rbxassetid://" seguido do id da sua animação
local player = Players.LocalPlayer
local lastLift = 0
local liftTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil
-- Carrega a animação de levantar uma vez por personagem, pelo Animator que a Roblox colocou no 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() -- sem argumentos: o servidor calcula a recompensa
end)
Para uma animação de levantar, faça uma no Animation Editor com a prioridade Action, publique e cole o ID dela em LIFT_ANIMATION_ID. Os passos de animação do guia de espada funcionam do mesmo jeito.
- Ajuste o limite do servidor à ação. O
LIFT_SECONDSsó deixa mais lentos os jogadores honestos: um trapaceiro pode disparar o Click pelo próprio código. Se levantar peso for o único jeito de ganhar, diminua oMAX_CLICKS_PER_SECONDno SimulatorConfig para o ritmo real, por exemplo 2 para uma levantada a cada 0,5 segundo, para um script não conseguir ganhar mais do que um jogador. Depois refaça a tabela de ritmo: todo tempo nela supõe 5 cliques por segundo. - Mantenha ou esconda o botão. O botão Click continua funcionando junto com a Tool. Para escondê-lo, adicione
clickButton.Visible = falselogo depois da linha do SimulatorClient que cria oclickButton. - Ganhar só no lugar certo. Para pagar só em uma academia ou em uma mina, confira no servidor onde o personagem está antes de contar o clique, por exemplo a distância dele até uma part da área. Uma checagem no LiftClient não impediria ninguém.
O que fazer depois: uma ordem de construção para simuladores
Um simulador é uma pilha de sistemas em cima deste loop. Monte esses sistemas em uma ordem em que cada um tenha algo para multiplicar, e teste depois de cada um. Esta é a ordem que sugerimos, com o guia de cada passo.
| Ordem | Sistema | Guia | Por que neste ponto |
|---|---|---|---|
| 1 | Ganhar, fazer upgrade, dar rebirth | Este guia | Tudo o que vem depois multiplica este loop, então ajuste os números dele primeiro com a tabela de ritmo. |
| 2 | Salvamento | Tutorial de DataStore, depois o Passo 4 | Progresso que zera ao entrar de novo acaba com um simulador. Adicione antes de qualquer coisa que os jogadores possam perder. |
| 3 | Ovos e pets como multiplicadores | Chocar ovos (em inglês) e pet que segue (em inglês) | O segundo objetivo ao lado das moedas: algo para colecionar que faz cada clique valer mais. |
| 4 | Áreas atrás de rebirths | Indo além | Um lugar para ir depois de um rebirth, com recompensas melhores conferidas no servidor. |
| 5 | Leaderboards | Guia de leaderboard | Um top 10 global de rebirths dá sentido à subida longa. |
| 6 | Recompensas diárias e códigos | Recompensas diárias e códigos (em inglês) | Motivos para voltar amanhã e depois de cada atualização. |
| 7 | Game passes | Guia de game pass (em inglês) | 2x moedas, auto clique ou um espaço extra de pet, conferidos no servidor. Venda quando o loop grátis já estiver divertido. |
Para as telas, os kits de UI para Roblox (em inglês) grátis incluem telas no estilo de simulador, com os scripts que fazem elas funcionarem.
Faça um simulador sem escrever os scripts
Um simulador ainda precisa de scripts: algo tem que adicionar as moedas, conferir os preços e salvar. Você não precisa escrever esses scripts sozinho:
- Um kit de simulador da Creator Store. Leia os scripts dele antes de publicar e confira que as moedas mudam só em um Script de servidor, nunca em um LocalScript.
- Um plugin gerador de simulador. A mesma checagem vale para tudo o que ele criar.
- Um agente de IA no Studio, como o RoCode, que pode montar esses mesmos três scripts no seu place aberto.
- O Build, no app da Roblox para celular. A documentação da Roblox diz que ele faz jogos 2D e 2.5D mais simples, como clickers, a partir de uma descrição, e está sendo liberado aos poucos por região.
Seja qual for a opção, rode os testes do Passo 5 e as checagens de exploit de Por que o servidor decide todos os números no resultado.
Indo além: pets, áreas, auto clique e leaderboards
Pets como multiplicadores
Um design comum faz de cada pet um multiplicador. Guarde a lista de ids de pets que o jogador tem na tabela salva dele, e faça o servidor multiplicar o clickValue pelo bônus de cada pet equipado. Choque os ovos no servidor: o cliente pede para abrir um ovo, e o servidor confere e cobra o preço e depois escolhe o pet com um sorteio com pesos. Nunca deixe o cliente sortear o ovo ou dizer qual pet ganhou. O guia de inventário mostra como guardar, salvar e mostrar itens, e os pets funcionam do mesmo jeito. O guia de chocar ovos (em inglês) monta o sorteio no servidor, e o guia de pet que segue (em inglês) faz os pets flutuarem ao lado do dono.
Áreas liberadas por rebirths
Uma área é uma parte do mapa com recompensas melhores atrás de uma barreira. Bloqueie a recompensa, não só a porta: o que paga dentro da área deve conferir os Rebirths do jogador na tabela do servidor antes de pagar. Uma porta que um LocalScript abre para quem pode entrar serve para o visual, mas exploiters podem mudar parts e mover o próprio personagem no dispositivo deles.
Auto clique como game pass
Um auto clicker vendido como game pass deve rodar no servidor. Leve o corpo do handler do Click para uma função como addClick(player), conecte o remote a ela e, para os donos do passe, chame essa função em um loop do servidor com task.wait(0.5), não com o wait obsoleto. Os auto cliques então contam para o mesmo limite por segundo que os cliques manuais. Confira a posse no servidor com MarketplaceService:UserOwnsGamePassAsync, como o guia de game pass (em inglês) faz para as vantagens dele. Um passe de 2x moedas funciona do mesmo jeito: multiplique o clickValue no servidor para os donos. Antes de definir o preço, a calculadora de taxa de Robux (em inglês) grátis mostra quanto cada venda paga a você depois da parte da Roblox, e a calculadora de DevEx (em inglês) mostra quanto esses Robux valem em dólares americanos.
Um top 10 global de rebirths
Os leaderstats só comparam jogadores no mesmo servidor. Para ranquear os Rebirths de todos os jogadores, escreva esses números em um ordered data store e leia de volta as primeiras entradas, como no Passo 4 do guia de leaderboard. Ordered data stores permitem menos escritas que os padrão, 30 + 5 × jogadores por minuto por servidor, então escreva quando um jogador sai e com um timer.
Números muito grandes
Os números do Luau são doubles, que guardam cerca de 15 dígitos significativos. Um IntValue guarda números inteiros até cerca de 9,2 quintilhões, mas a Roblox avisa que valores acima de 2^53 (cerca de 9 quatrilhões) perdem precisão nos scripts. Com estas configurações o preço do rebirth passa desse ponto no 29º rebirth. Se o seu jogo vai além disso, troque os valores dos leaderstats para NumberValue (mude IntValue nos dois scripts), que guarda números muito maiores com a mesma precisão de uns 15 dígitos, e adicione sufixos ao short().
O que faz um jogo de simulador dar certo
Um simulador é um jogo de números. O clique, o upgrade e o rebirth acima são o loop inteiro; o que decide se os jogadores ficam é como esses números crescem. A cada poucos minutos o jogador deve conseguir pagar algo que deixe os próximos minutos mais rápidos, e toda sessão deve terminar perto de um objetivo que dê vontade de voltar.
- Crescimento que dura. Os preços dos upgrades crescem mais rápido que a renda, então cada nível demora um pouco mais. Um rebirth zera as moedas em troca de um multiplicador permanente, o que transforma uma área antiga em uma rápida e faz a subida parecer nova.
- Coisas para colecionar. Áreas para liberar, pets de ovos (em inglês) que multiplicam os ganhos e ferramentas para melhorar dão aos jogadores uma lista de objetivos além de um número só.
- Números grandes que continuam legíveis. Mostre 1.5M, não 1500000, e guarde números que o servidor ainda consiga comparar quando ficarem grandes.
Monetização que combina com um simulador
Passes comuns multiplicam moedas, dão um espaço extra de pet, chocam mais ovos de uma vez ou fazem auto clique. Venda esses benefícios como game passes e confira no servidor. Pacotes de moedas são developer products. Se ovos ou qualquer coisa com resultado aleatório podem ser comprados com Robux, ou com uma moeda comprada com Robux, a Roblox exige que as chances apareçam antes da compra: leia paid random items (em inglês) antes de montar a loja.
O que faz os jogadores voltarem
Progresso salvo, uma área ou um conjunto de pets novo nas atualizações, recompensas diárias, códigos (em inglês) anunciados com as atualizações e um leaderboard de rebirths. Mais gêneros, cada um com seu loop, sistemas e plano de construção: gêneros de jogos no Roblox (em inglês).
Erros comuns e como resolver
Abra a janela Output (menu Window, depois Output) antes de apertar Play. A maioria dos problemas mostra um aviso ou um erro ali, com o nome do script e a linha.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("SimulatorRemotes")'
O LocalScript está esperando os remotes, que o SimulatorService cria quando começa. Confira que o SimulatorService é um Script, não um LocalScript, que ele está dentro do ServerScriptService e que o Output não mostra nenhum erro dele. O mesmo aviso para SimulatorConfig quer dizer que o módulo não está no ReplicatedStorage ou está com outro nome.
Os botões nunca aparecem
O LocalScript espera os seus leaderstats antes de montar a tela. Se o Output mostra Infinite yield possible em leaderstats, o SimulatorService ainda não preparou você. Com SAVE_PROGRESS = true ele espera o PlayerData, então confira que o PlayerData está no ServerScriptService e carrega sem erros.
O Output diz "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"
O salvamento está ligado, mas o módulo PlayerData ainda não tem os campos novos. Adicione esses campos aos DEFAULTS dele como no Passo 4 e aperte Play de novo.
Os "+1" aparecem, mas as minhas moedas não sobem
O servidor não está contando os cliques. Ou o SimulatorService deu um erro (procure texto vermelho dele no Output), ou os cliques chegam mais rápido do que o MAX_CLICKS_PER_SECOND permite. Se os jogadores chegam ao limite jogando normalmente, aumente o limite no SimulatorConfig.
A linha de status diz "No answer from the server. Try again."
A chamada ao BuyUpgrade ou ao Rebirth falhou em vez de devolver uma resposta. A causa mais comum é um erro dentro do SimulatorService enquanto ele cuidava do pedido, então procure um erro vermelho dele no Output: ele diz a linha.
O contador de moedas na tela e a lista de jogadores mostram números diferentes
Outro script também está criando uma pasta leaderstats, então cada jogador tem duas, e o LocalScript pode estar lendo a outra. Apague o script extra: o SimulatorService cria Coins e Rebirths sozinho.
As minhas moedas zeram toda vez que eu entro de novo
O salvamento está desligado. Siga o Passo 4. Se ele está ligado e as moedas ainda zeram no Studio, confira que o acesso do Studio aos serviços de API está ligado na sua cópia de teste, como explica o tutorial de DataStore.
Crie com o RoCode
Se você prefere não colar isso à mão, o RoCode pode montar tudo no place que você tem aberto. Ele é um agente de IA independente, não feito pela Roblox: você descreve o sistema no chat na web dele, e o plugin dele para o Roblox Studio cria os scripts no seu Explorer, então você não fica copiando código de uma janela de chat.
Faça um simulador de clicker: um botão Click grande que dá moedas iguais ao meu nível de Click Power vezes (rebirths + 1), um botão Upgrade que custa 10 moedas e aumenta 1,5 vez a cada nível, e um botão Rebirth com 1.000 moedas que zera as moedas e os upgrades. Deixe os números no servidor e limite os cliques a 15 por segundo. Eu já tenho um módulo PlayerData.
- Pode ler primeiro o seu módulo PlayerData e qualquer script de leaderstats com Search Scripts e Read Script, para adicionar campos aos seus dados existentes em vez de escrever um segundo script de salvamento
- Pode montar a base da tela com o layout de HUD do Build UI (com o plugin 3.9 ou mais recente, no estilo de simulador dele), ou montar os botões em um LocalScript, e escreve o ModuleScript, o Script de servidor e o LocalScript com Create Script
- É instruído a checar a compilação de cada script que escreve com Check Script, que compila o script no Studio sem rodá-lo
- Cria um ponto de desfazer antes e depois de cada lote de mudanças, então Ctrl+Z volta um lote de cada vez
O RoCode não consegue criar game passes nem developer products, nem enviar meshes e ícones de pets: faça isso no Creator Hub e no Studio. Com o plugin 3.9.11 ou mais recente, o RoCode pode testar o seu jogo no Studio e controlar um personagem de teste para conferir se funciona, e com o plugin 3.9.15 ou mais recente o personagem de teste consegue clicar em botões na tela, por exemplo apertar Click e conferir se as Coins subiram. Ele decide quando rodar um teste, até 2 por build mais 1 para conferir a própria correção, e confere só o que escolheu testar, então teste o loop você mesmo. Um simulador inteiro são vários prompts, um sistema por vez: como funciona montar um sistema por prompt com o RoCode. Como o RoCode se conecta ao Studio.
Perguntas frequentes
Como fazer um simulador no Roblox sem saber programar?
Um simulador que funciona precisa de scripts: algo tem que adicionar moedas, conferir preços e salvar o progresso. Você pode colar os três scripts deste guia como estão e só mudar os números no SimulatorConfig, ou deixar um kit da Creator Store, um plugin ou um agente de IA fazer esses scripts e conferir se o servidor decide as moedas. As opções.
Como funciona um sistema de rebirth?
Um rebirth troca as suas moedas e upgrades por um bônus permanente. Neste guia o primeiro rebirth custa 1.000 moedas; ele define Coins como 0 e Click Power como nível 1 e soma 1 a Rebirths, e cada clique passa a ser multiplicado por Rebirths + 1. Cada rebirth custa três vezes mais que o anterior.
Como fazer um simulador de força ou de levantar peso?
Dê aos jogadores uma Tool, como um haltere, cujo LocalScript dispara o mesmo remote Click no Tool.Activated. O servidor calcula a recompensa exatamente como para um clique no botão. Diminua o limite de cliques do servidor para o ritmo de levantar, para um script não ganhar mais que um jogador. A versão de levantar peso tem o script.
Quais sistemas um jogo de simulador precisa?
Primeiro o loop de ganhar, fazer upgrade e dar rebirth, depois o salvamento, depois pets ou outra coleção que multiplique os ganhos, áreas liberadas por rebirths, leaderboards, recompensas diárias e códigos, e por último os game passes. A ordem de construção tem um guia para cada um.
Quanto tempo deve levar um rebirth?
Tempo o bastante para os jogadores comprarem vários upgrades antes, e pouco o bastante para a primeira sessão chegar a um. Com os números deste guia o primeiro rebirth chega depois de cerca de 1,2 minuto a 5 cliques por segundo; aumentar o REBIRTH_BASE_COST para 10.000 leva a cerca de 8 minutos. A tabela de ritmo mostra mais configurações.
Como impedir auto clicker no Roblox?
O servidor conta no máximo 15 cliques por jogador em cada janela de um segundo e ignora o resto. Abaixo desse limite um script parece igual a um jogador rápido, então o limite é o que protege a sua economia. Você também pode vender o auto clique como um game pass que roda no servidor.
Por que as minhas moedas zeram quando eu entro de novo?
Nada salva as moedas ainda. Adicione o módulo PlayerData do tutorial de DataStore, adicione PowerLevel e Rebirths aos DEFAULTS dele e defina SAVE_PROGRESS = true no SimulatorService, como no Passo 4.
Como colocar pets no meu simulador?
Faça de cada pet um multiplicador que o servidor aplica aos cliques. Choque os ovos no servidor com um sorteio com pesos, salve os ids dos pets do jogador junto com o resto dos dados dele e mostre os pets com uma GUI de inventário como a do guia de inventário.
Os jogadores devem clicar em uma part ou em um botão?
Os dois funcionam. Um botão na tela combina com celulares, e uma part com um ClickDetector combina com um jogo que acontece no mundo. A documentação da Roblox diz que o servidor não faz nenhuma checagem nos eventos de ClickDetector, então limite a frequência desses cliques no servidor do mesmo jeito.
Fontes e leitura extra
- Roblox Creator Docs: Securing the client-server boundary (em inglês). limite de frequência, o exemplo da loja no jogo e eventos de ClickDetector
- Roblox Creator Docs: Security and cheat mitigation tactics (em inglês). o que um exploiter controla no próprio dispositivo
- Roblox Creator Docs: Remote events and callbacks (em inglês). FireServer, o parâmetro do jogador, InvokeServer e OnServerInvoke
- Roblox Creator Docs: Leaderboards (em inglês). leaderstats e ordered data stores
- Roblox Creator Docs: Data store error codes and limits (em inglês). limites de escrita por servidor para data stores padrão e ordenados
- Roblox Engine API: GuiButton (em inglês). Activated no computador, no celular e no console
- Roblox Engine API: GuiService (em inglês). AutoSelectGuiEnabled e selecionar objetos de GUI com um controle
- Roblox Engine API: IntValue (em inglês). o intervalo de 64 bits e a perda de precisão acima de 2^53
- Roblox Creator Docs: Size modifiers and constraints (em inglês). UIAspectRatioConstraint e UISizeConstraint
- Roblox Creator Docs: Studio testing modes (em inglês). Device Simulator e Controller Emulator
Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 14 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.