La respuesta corta
Un simulador de Roblox es un bucle: haces clic para ganar monedas, las gastas en mejoras que ganan más rápido y luego haces rebirth para conseguir un multiplicador permanente. Guarda los precios en un ModuleScript en ReplicatedStorage. Deja que un Script en ServerScriptService sea dueño de los Coins, el Click Power y los Rebirths de cada jugador, que cuente como máximo 15 clics por segundo desde un RemoteEvent Click y que venda mejoras y rebirths mediante RemoteFunctions después de comprobar el precio. Un LocalScript muestra los botones Click, Upgrade y Rebirth. Con los números de esta guía, un jugador que hace 5 clics por segundo llega al primer rebirth en unos 1.2 minutos, y la tabla de ritmo muestra qué cambiar para una subida más larga.
- Un clic no envía nada más que el clic. El servidor calcula cuánto vale, así que un cliente modificado no puede darse monedas.
- Guarda la tabla entera con un temporizador y cuando los jugadores salen, nunca en cada clic. Roblox permite a cada servidor 60 + 40 × jugadores escrituras de data store por minuto.
- ¿Sin programar? Un kit de la Creator Store, un plugin o un agente de IA pueden construir el mismo bucle. Comprueba que el servidor decide las monedas: las opciones.
- ¿Levantar pesas o minar en vez de un botón? Una Tool puede disparar el mismo remote Click: la versión de levantar pesas. Después añade sistemas en el orden de construcción de abajo.
En esta página
Cómo funciona el bucle principal de un simulador
Un simulador es un bucle de tres acciones. El jugador hace algo simple una y otra vez para ganar una moneda, la gasta en mejoras que la ganan más rápido y, cuando las mejoras se vuelven caras, hace rebirth: renuncia a sus monedas y mejoras a cambio de un bonus que nunca desaparece, y vuelve a subir más rápido. Otros simuladores cambian el clic por levantar pesas, minar o recolectar, pero el bucle de fondo es el mismo.
| Acción | Qué cuesta | Qué da | Quién decide |
|---|---|---|---|
| Click | Nada | Monedas igual a Click Power × (Rebirths + 1) | El servidor, que cuenta como máximo 15 clics en cada ventana de un segundo |
| Upgrade | 10 monedas, y luego 1.5 veces el último precio por cada nivel | Un nivel más de Click Power, hasta el nivel 50 | El servidor, con su propia copia de los precios |
| Rebirth | 1,000 monedas, y luego 3 veces el último precio por cada rebirth | Monedas a 0 y Click Power al nivel 1, más un +1 permanente al multiplicador | El servidor |
Cada número vive en el servidor. El dispositivo del jugador dibuja los botones y pide cosas ("hice clic", "quiero una mejora"); el servidor decide cuánto vale eso y si puede pasar. Los scripts de clicker que acaban explotados suelen sumar monedas en un LocalScript, o dejan que el cliente envíe cuántas monedas sumar.
| Pieza | Dónde va | Qué hace |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | Precios, límites y las fórmulas del valor de un clic, el precio de una mejora y el precio de un rebirth. Lo leen los dos lados. |
Script SimulatorService | ServerScriptService | Guarda los números de cada jugador, gestiona clics, mejoras y rebirths, y rellena leaderstats. |
Folder SimulatorRemotes | ReplicatedStorage (lo crea SimulatorService) | El RemoteEvent Click y las RemoteFunctions BuyUpgrade y Rebirth. |
LocalScript SimulatorClient | StarterPlayerScripts | Construye los botones, envía clics y peticiones, y muestra los números del servidor. |
ModuleScript PlayerData (opcional) | ServerScriptService | Guarda el progreso entre visitas. Viene del tutorial de DataStore y solo hace falta para el Paso 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
Paso 1: Pon los precios y las fórmulas en un módulo
Cada número que quieras ajustar va en un solo ModuleScript: cuánto vale un clic, cuánto cuesta cada mejora y cada rebirth, y el límite de clics. El servidor lo usa para decidir, y el LocalScript lo usa para mostrar los precios en los botones, así que un cambio es una sola edición en un solo sitio.
- En el Explorer, pasa el ratón sobre ReplicatedStorage, haz clic en el botón + e inserta un ModuleScript.
- Cámbiale el nombre a
SimulatorConfig(los nombres distinguen mayúsculas) y reemplaza su contenido con el código de abajo.
-- Todos los números del bucle principal y las fórmulas que usan los dos lados. El cliente
-- solo los usa para mostrar precios; el servidor usa su propia copia para decidir.
local SimulatorConfig = {}
SimulatorConfig.UPGRADE_BASE_COST = 10 -- precio del nivel 2 de Click Power
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- cada nivel cuesta 1.5 veces el anterior
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- monedas necesarias para el primer rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- cada rebirth cuesta 3 veces el anterior
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- los clics por encima de este número en un segundo se ignoran
-- Monedas por un clic: el nivel de Click Power, multiplicado por 1 + el número de rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
return powerLevel * (rebirths + 1)
end
-- Precio del siguiente nivel de Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end
-- Monedas necesarias para el siguiente rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end
return SimulatorConfig
Los jugadores pueden leer un ModuleScript en ReplicatedStorage, así que estos precios son públicos. No pasa nada: igual salen en los botones. El cliente y el servidor ejecutan cada uno su propia copia del módulo, así que un jugador que edita los números en su dispositivo no cambia nada en el servidor.
| Nivel de Click Power | Precio del siguiente nivel | Monedas por clic, sin rebirths | Monedas por clic, 1 rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
Los rebirths cuestan 1,000 monedas, luego 3,000 y luego 9,000, porque rebirthCost multiplica el precio por 3 cada vez. Después de un rebirth cada clic vale el doble, después de dos rebirths el triple, y así sucesivamente.
Cuánto tarda un rebirth con estos números
Las fórmulas deciden cuánto dura el bucle, así que vale la pena hacer las cuentas antes que los jugadores. La tabla supone un jugador que hace rebirth en cuanto puede pagarlo y, si no, compra el siguiente nivel de Click Power siempre que puede pagarlo y cuesta menos que el rebirth. Los tiempos cuentan desde un inicio nuevo, así que la última columna es el tiempo total hasta 3 rebirths.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1,000 (esta guía) | 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 |
Sin rebirths, el nivel 5 de Click Power llega tras 34 clics, el nivel 10 tras 122 y el nivel 13 tras 285. Con los números por defecto el jugador deja de mejorar ahí, porque el nivel 14 cuesta 1,297 monedas, más que el rebirth de 1,000 monedas, y el primer rebirth llega tras 362 clics en total. Con el límite del servidor de 15 clics por segundo, divide cada tiempo entre 3. Si cambias cualquier número en SimulatorConfig, estos tiempos cambian con él, así que vuelve a calcularlos.
Ajustar el crecimiento
Los dos números _GROWTH fijan lo rápido que suben los precios. Con 1.5, cada mejora cuesta la mitad más que la anterior, mientras que cada nivel suma solo una moneda por clic (antes del multiplicador de rebirth), así que cada nivel nuevo tarda más en pagarse solo. Esa ralentización es lo que hace que un rebirth valga la pena. Sube el crecimiento para una subida más larga, bájalo para una más rápida, y mantén REBIRTH_BASE_COST lo bastante alto para que los jugadores compren algunas mejoras antes de su primer rebirth.
Para un primer rebirth después de varios minutos en vez de uno más o menos, sube REBIRTH_BASE_COST a 5,000 o 10,000.
Paso 2: Añade el script del servidor
Este Script es dueño de cada número. Crea los remotes, le da a cada jugador una carpeta leaderstats con Coins y Rebirths, y responde a las tres peticiones. Pasa el ratón sobre ServerScriptService, inserta un Script, cámbiale el nombre a SimulatorService y reemplaza su contenido con esto:
-- Es dueño de cada número: los clics ganan monedas aquí, las mejoras y los rebirths se compran aquí,
-- y leaderstats solo muestra el resultado.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- false: todos empiezan de cero en cada visita. true: carga y guarda con el módulo PlayerData
-- del tutorial de DataStore (antes añade PowerLevel = 1 y Rebirths = 0 a sus 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 } = {} -- cuándo empezó la ventana de un segundo actual de este jugador
local clickCount: { [Player]: number } = {} -- clics contados en esa ventana
-- Copia los números del servidor a lo que ven los jugadores: leaderstats y un 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
-- Prepara a un jugador con los datos recibidos (números nuevos o una tabla guardada)
local function setup(player: Player, data: Stats)
playerStats[player] = data
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats"
for _, name in { "Coins", "Rebirths" } do
local value = Instance.new("IntValue")
value.Name = name
value.Parent = leaderstats
end
leaderstats.Parent = player
refresh(player)
end
-- Un clic no lleva números: el servidor calcula cuánto 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 -- un auto-clicker o un script que dispara el remote en bucle
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
-- Un rebirth cambia monedas y mejoras por un 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 iniciales: nuevos, o la tabla que carga y guarda el módulo PlayerData
if SAVE_PROGRESS then
type PlayerDataModule = {
Loaded: RBXScriptSignal,
Get: (player: Player) -> any,
}
local PlayerData = require(ServerScriptService:WaitForChild("PlayerData")) :: PlayerDataModule
local function onLoaded(player: Player)
local data = PlayerData.Get(player)
if not data or playerStats[player] then
return
end
if type(data.Coins) ~= "number" or type(data.PowerLevel) ~= "number" or type(data.Rebirths) ~= "number" then
warn("SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module")
return
end
setup(player, data) -- la misma tabla que guarda PlayerData, así que cada cambio se guarda
end
PlayerData.Loaded:Connect(onLoaded)
for _, player in Players:GetPlayers() do
onLoaded(player) -- quien ya tenía sus datos cargados antes de que empezara este 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)
El Click Power le llega al jugador como un atributo PowerLevel en su objeto Player, no como un tercer valor de leaderstats, así que la lista de jugadores solo muestra Coins y Rebirths. Los atributos que pone el servidor se replican al dispositivo del jugador; un cambio que hace un jugador en su propio dispositivo se queda ahí.
Los clics y el límite de ritmo
El remote Click no lleva argumentos. En el servidor, el primer parámetro de un manejador de OnServerEvent es siempre el jugador que lo disparó, así que el servidor sabe quién hizo clic, busca su nivel de Click Power y sus Rebirths, y suma clickValue a sus Coins. En la petición no hay nada que un tramposo pueda cambiar.
La guía de seguridad de Roblox dice que nunca confíes solo en un límite de ritmo en el cliente, y pone dar moneda entre las acciones que hay que limitar. El servidor cuenta los clics de cada jugador en ventanas de un segundo: el primer clic abre una ventana y, cuando ya se contaron 15 clics, el resto se ignora hasta que pase un segundo desde que empezó la ventana. Un script que dispara el remote en bucle no consigue que se cuenten más de 15 clics en cada ventana. Para permitir clics más rápidos o más lentos, cambia MAX_CLICKS_PER_SECOND en SimulatorConfig.
Mejoras y rebirths
BuyUpgrade y Rebirth son RemoteFunctions, así que el botón puede esperar la respuesta y mostrarla. Cada manejador lee el precio de la copia de SimulatorConfig del servidor, comprueba los Coins del jugador y solo entonces cambia algo. Devuelve true o false y un mensaje como "You need 5 more coins.", que el LocalScript muestra en una línea de estado.
Entre la comprobación del precio y el cambio nada espera ni cede, así que dos peticiones del mismo jugador no pueden pasar las dos la comprobación antes de que la primera se lleve las monedas. Un rebirth pone Coins en 0 y Click Power en el nivel 1 y suma 1 a Rebirths, que la fórmula del clic convierte en un multiplicador de Rebirths + 1.
El interruptor SAVE_PROGRESS
Con SAVE_PROGRESS = false, cada jugador empieza con 0 monedas en cada visita, que es lo que quieres mientras construyes. El Paso 4 lo activa. Entonces el script espera a que el módulo PlayerData cargue a cada jugador y trabaja directamente sobre la tabla que guarda ese módulo, así que cada moneda y cada rebirth se guardan sin código extra.
Paso 3: Construye los botones
Este LocalScript construye toda la pantalla en código: el contador de monedas arriba, un botón Click grande en el centro, los botones Upgrade y Rebirth abajo, y una línea de estado para las respuestas del servidor. Nunca cambia un número por su cuenta.
- En el Explorer, despliega StarterPlayer, pasa el ratón sobre StarterPlayerScripts e inserta un LocalScript llamado
SimulatorClient. - Reemplaza su contenido con el código de abajo y pulsa Play.
-- Construye los botones del simulador y muestra los números del servidor. Nunca los cambia.
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))
-- Mantiene el botón Click cuadrado, a escala de la pantalla y nunca mayor de 200 por 200,
-- para que en un teléfono quepa entre el contador de monedas y los botones de abajo
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()
-- Un "+N" que sube flotando desde el botón. El número es una estimación solo para mostrar;
-- el servidor decide cuánto vale de verdad el clic.
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)
Los botones usan Activated, que Roblox dispara con un clic izquierdo en ordenador, un toque en móvil y A (o equis) en un mando en el modo de navegación de UI.
En un mando, A solo pulsa un botón que está seleccionado. Con GuiService.AutoSelectGuiEnabled activado, el botón Select del mando selecciona tus botones en pantalla; después los jugadores pueden moverse entre ellos y pulsar A. Si prefieres que un botón del mando haga clic directamente, asigna uno con ContextActionService y dispara desde él el mismo remote Click.
Cuatro detalles del script:
- El botón Click se escala con la pantalla. Su tamaño es una fracción de la pantalla, un
UIAspectRatioConstraintlo mantiene cuadrado y unUISizeConstraintlo limita a 200 por 200 píxeles. En un monitor mide 200 píxeles de ancho; en un teléfono se encoge para caber entre el contador de monedas y los botones de abajo. Mantenlo separado de ellos si mueves cosas: Rebirth no pide confirmación, así que un toque sin querer ahí puede reiniciar las monedas y mejoras del jugador. - El "+N" que aparece es solo visual. Usa la copia de la fórmula del cliente. Si el servidor ignora un clic por el límite de ritmo, el número aparece igual pero las monedas no cambian.
short()mantiene legibles los números grandes. 1,234 se muestra como 1.2K y 5,600,000 como 5.6M. Redondea hacia abajo, así que el contador nunca muestra más de lo que tienes. Añade entradas aUNITSpara números más allá de T (billones).- La pantalla se actualiza con eventos. Escucha los valores Coins y Rebirths y el atributo PowerLevel, así que los precios de los botones son correctos cambien como cambien los números.
La ScreenGui tiene ResetOnSpawn en false, así que se queda cuando el personaje reaparece. Aquí eso importa: un LocalScript en StarterPlayerScripts se copia al jugador una sola vez, cuando entra, así que no volvería a construir la pantalla.
Paso 4: Guarda el progreso con PlayerData
Hasta ahora todo se reinicia cuando un jugador sale. En vez de añadir un segundo script de guardado, el simulador se conecta al módulo PlayerData del tutorial de DataStore. Ese módulo ya reintenta las peticiones que fallan, guarda automáticamente cada 180 segundos, guarda cuando un jugador sale y cuando el servidor se apaga, y nunca guarda a un jugador cuyos datos no se pudieron cargar.
- Sigue el Paso 1 del tutorial de DataStore para añadir el ModuleScript
PlayerDataa ServerScriptService. Para probar el guardado en Studio, activa el acceso de Studio a los servicios de API en una copia de prueba de tu juego, como explica su primera sección. SimulatorService hace require del módulo por su cuenta, así que para esto no necesitas el scriptMaindel tutorial. - En PlayerData, añade
PowerLevel = 1,yRebirths = 0,dentro de la tablaDEFAULTS, junto aCoins = 0,. - En el mismo módulo, añade
PowerLevel: number,yRebirths: number,al tipoData, para que la comprobación estricta de tipos conozca los campos nuevos. - En SimulatorService, cambia
local SAVE_PROGRESS = falseporlocal SAVE_PROGRESS = true.
Los jugadores que guardaron antes de que añadieras los campos los reciben automáticamente: la función migrate de PlayerData rellena cualquier campo de DEFAULTS que le falte a una tabla guardada, así que empiezan con Click Power en nivel 1 y 0 rebirths y conservan sus Coins. Si te saltas el paso 2, SimulatorService muestra una advertencia que dice qué campos añadir y no prepara al jugador.
Por qué el simulador escribe en la tabla de PlayerData
Con el guardado activado, SimulatorService no copia los números a ningún sitio. PlayerData.Get(player) devuelve la tabla viva que guarda el módulo, y el simulador cambia Coins, PowerLevel y Rebirths en esa misma tabla. Hay una sola copia de cada número y un solo script que escribe en el data store. Dos scripts que guardan la misma clave se sobrescriben entre sí, y uno de ellos puede guardar números más viejos encima de los del otro.
No crees también leaderstats en un manejador de Loaded, como sugiere el tutorial de DataStore para otros juegos: SimulatorService ya crea Coins y Rebirths a partir de la tabla cargada. Si un script de leaderboard ya crea leaderstats, bórralo.
Por qué no guardar en cada clic
Roblox permite a cada servidor 60 + 40 × jugadores escrituras de data store estándar por minuto (la tabla de límites del tutorial de DataStore tiene el resto). Guardar en cada clic a 15 clics por segundo serían 900 escrituras por minuto para un solo jugador, muy por encima de las 100 que tiene un servidor con un jugador. Guardar la tabla entera cada 180 segundos, cuando el jugador sale y cuando el servidor se apaga, cuesta solo unas pocas escrituras por jugador, y un fallo pierde como mucho el progreso desde el último guardado automático.
Si una carga falla, el módulo deja jugar al jugador con números nuevos pero nunca los guarda, así que una mala carga no puede reemplazar el progreso real. El tutorial explica cómo lo gestiona el módulo.
Por qué el servidor decide cada número
Los exploiters controlan su propio dispositivo. La guía de seguridad de Roblox dice que pueden cambiar cualquier cosa en su copia local del juego, y disparar o invocar cualquier RemoteEvent o RemoteFunction tantas veces como quieran con cualquier argumento. La economía de un simulador es tan segura como su script del servidor.
| Un exploiter intenta | Si decidiera el cliente | Lo que hace SimulatorService |
|---|---|---|
| Disparar Click en bucle lo más rápido posible | Monedas ilimitadas | Cuenta como máximo 15 clics en cada ventana de un segundo e ignora el resto. |
| Enviar una cantidad de monedas con el clic | Elige su propia recompensa | Ignora cualquier argumento. El valor de un clic sale de los números del servidor. |
| Comprar una mejora o un rebirth sin suficientes monedas | Mejoras gratis | Compara el precio con los Coins del servidor y responde "You need N more coins." |
| Editar Coins en leaderstats en su propia pantalla | Gastar monedas que no tiene | Nunca lee leaderstats. Solo escribe en ellos, desde su propia tabla. |
| Poner el atributo PowerLevel en su Player | Un clic más grande | Nunca lee el atributo, y el cambio se queda en su dispositivo. |
| Invocar Rebirth dos veces en el mismo momento | Dos rebirths por el precio de uno | Vuelve a comprobar el precio en cada llamada, y nada cede entre la comprobación y el cambio. |
| Cambiar los precios en su copia de SimulatorConfig | Mejoras más baratas | Usa su propia copia del módulo. |
La regla vale para cada remote de un simulador: envía lo que el jugador quiere hacer, nunca lo que vale. La guía de RemoteEvents explica con más detalle cómo validar los argumentos de un remote.
Patrones que evitar en scripts de clicker copiados
| Patrón | El problema | Esta guía |
|---|---|---|
Un LocalScript suma monedas con leaderstats.Coins.Value += 1 | El cambio se queda en ese dispositivo, y los exploiters controlan su dispositivo | El servidor suma las monedas |
clickEvent:FireServer(amount) | El cliente elige su propia recompensa | Click no envía argumentos |
| Sin límite de ritmo en el servidor | La documentación de Roblox dice que nunca confíes solo en un límite en el cliente | Como máximo 15 clics en cada ventana de un segundo |
SetAsync en cada clic o mejora | Agota el presupuesto de escrituras por servidor | PlayerData guarda cada 180 segundos, al salir y al apagarse el servidor. Guarda al momento con PlayerData.SaveNow solo después de algo que no se puede perder, como una compra con Robux. |
| Un segundo script de data store solo para el simulador | Dos scripts que guardan una clave se sobrescriben entre sí | Escribe en la tabla de PlayerData |
Bucles while wait(1) do para ingresos pasivos | Roblox marca el wait global como obsoleto, reemplazado por task.wait | task.wait (consulta Cómo ampliarlo) |
MouseButton1Click en los botones | Documentado para clics de ratón | Activated, para ratón, toque y mando |
Paso 5: Pruébalo
Haz los pasos del 1 al 8 con SAVE_PROGRESS = false en SimulatorService, para que cada prueba empiece con números nuevos. Si ya activaste el guardado en el Paso 4, ponlo en false por ahora y otra vez en true para el paso 9.
- Pulsa Play. Arriba en la pantalla dice 0 coins, el botón verde dice Upgrade: 10 y el naranja dice Rebirth: 1.0K.
- Pulsa el botón morado Click! diez veces. Cada clic muestra un +1 dorado, y Coins en la lista de jugadores sube 1.
- Pulsa Upgrade. Las monedas vuelven a 0, la línea de estado se pone verde con "Click Power is now level 2." y el botón ahora dice Upgrade: 15. A partir de ahora cada clic da 2 monedas.
- Antes de volver a hacer clic, pulsa Rebirth. La línea de estado dice "You need 1000 more coins to rebirth." y no cambia nada.
- Para probar un rebirth sin 1,000 clics, detén la prueba, cambia
Coins = 0porCoins = 1000en la línea cerca del final de SimulatorService que prepara a los jugadores nuevos, y pulsa Play. Pulsa Rebirth: las monedas bajan a 0, Rebirths en la lista de jugadores sube a 1, la línea de estado dice "Rebirth 1! Every click is now worth x2." y el botón ahora dice Rebirth: 3.0K. Cada clic da ahora 2 monedas con Click Power en nivel 1. Después devuelve la línea a 0. - Para ver el límite de ritmo, pon
MAX_CLICKS_PER_SECONDen 2 en SimulatorConfig y haz clic rápido. Los números siguen apareciendo, pero Coins sube como mucho lo que valen 2 clics en cada segundo. Vuelve a ponerlo en 15. - Elige un teléfono en el Device Simulator de Studio (una beta de Studio; el Device Emulator antiguo también sirve) y pulsa Play. Comprueba que el botón Click no tapa ni el contador de monedas ni los botones Upgrade y Rebirth, y que la línea de estado se ve sin tocarlo cuando pulsas Upgrade.
- Conecta un mando, o abre el Controller Emulator de Studio (Controller, en la pestaña Emulation) durante la prueba, pulsa Select y comprueba que puedes llegar a los tres botones y pulsarlos con A.
- Con el guardado activado (Paso 4) y otra vez
SAVE_PROGRESS = true, gana algunas monedas, pulsa Stop y luego vuelve a pulsar Play. Tus Coins, tu nivel de Click Power y tus Rebirths vuelven.
Conviértelo en un simulador de levantar pesas o de minería
Muchos simuladores cambian el botón por una acción en el mundo: levantar una mancuerna, dar un golpe con un pico, lanzar espadazos al aire. Por debajo es el mismo clic. Una Tool puede disparar el mismo remote Click, así que SimulatorService, sus precios y su límite de ritmo se quedan exactamente como están.
- En el Explorer, pasa el ratón sobre StarterPack, inserta una Tool y llámala
Dumbbell. Inserta dentro una Part llamadaHandle, dale forma de mancuerna y desmarca Anchored, como en los pasos de la Tool de la guía de la espada. - Inserta en la Tool un LocalScript llamado
LiftClienty pega el código de abajo. - Pulsa Play, equipa la mancuerna y haz clic. Coins sube lo que vale tu Click Power en cada levantamiento, igual que con el botón.
-- LocalScript dentro de la Tool Dumbbell, llamado LiftClient.
-- Cada levantamiento es un clic: dispara el mismo remote Click que el botón, y el servidor
-- decide cuánto vale y cuántos cuentan.
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 -- tiempo entre levantamientos en este dispositivo; el servidor tiene su propio límite
local LIFT_ANIMATION_ID = "" -- opcional: "rbxassetid://" seguido del id de tu animación
local player = Players.LocalPlayer
local lastLift = 0
local liftTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil
-- Carga la animación de levantar una vez por personaje, con el Animator que Roblox puso en el 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() -- sin argumentos: el servidor calcula la recompensa
end)
Para una animación de levantar, crea una en el Animation Editor con la prioridad Action, publícala y pega su ID en LIFT_ANIMATION_ID. Los pasos de animación de la guía de la espada funcionan igual.
- Ajusta el límite del servidor a la acción.
LIFT_SECONDSsolo frena a los jugadores honestos: un tramposo puede disparar Click desde su propio código. Si levantar es la única forma de ganar, bajaMAX_CLICKS_PER_SECONDen SimulatorConfig al ritmo real, por ejemplo 2 para un levantamiento cada 0.5 segundos, para que un script no pueda ganar más de lo que podría un jugador. Después vuelve a calcular la tabla de ritmo: todos sus tiempos suponen 5 clics por segundo. - Deja o esconde el botón. El botón Click sigue funcionando junto a la Tool. Para esconderlo, añade
clickButton.Visible = falsejusto después de la línea de SimulatorClient que creaclickButton. - Ganar solo en el sitio correcto. Para pagar solo en un gimnasio o una mina, comprueba en el servidor dónde está el personaje antes de contar el clic, por ejemplo su distancia a una parte de la zona. Una comprobación en LiftClient no frenaría a nadie.
Qué construir después: un orden de sistemas para tu simulador
Un simulador es una pila de sistemas encima de este bucle. Constrúyelos en un orden en el que cada uno tenga algo que multiplicar, y prueba después de cada uno. Este es el orden que sugerimos, con la guía de cada paso.
| Orden | Sistema | Guía | Por qué en este punto |
|---|---|---|---|
| 1 | Ganar, mejorar, rebirth | Esta guía | Todo lo que viene después multiplica este bucle, así que ajusta primero sus números con la tabla de ritmo. |
| 2 | Guardado | Tutorial de DataStore, y luego el Paso 4 | Un progreso que se reinicia al volver a entrar acaba con un simulador. Añádelo antes que cualquier cosa que los jugadores puedan perder. |
| 3 | Huevos y mascotas como multiplicadores | Egg hatching y pet follow (en inglés) | El segundo objetivo junto a las monedas: algo que coleccionar que hace que cada clic valga más. |
| 4 | Zonas detrás de rebirths | Cómo ampliarlo | Un sitio al que ir después de un rebirth, con mejores recompensas que comprueba el servidor. |
| 5 | Leaderboards | Guía de leaderboard | Un top 10 global de rebirths le da sentido a la subida larga. |
| 6 | Recompensas diarias y códigos | Recompensas diarias y códigos (en inglés) | Motivos para volver mañana y después de cada actualización. |
| 7 | Game passes | Guía de game pass (en inglés) | Monedas x2, auto-click o un hueco extra para mascotas, comprobados en el servidor. Véndelos cuando el bucle gratis ya sea divertido. |
Para las pantallas, los kits de UI de Roblox gratis (en inglés) incluyen pantallas al estilo de un simulador, con los scripts que las hacen funcionar.
Haz un simulador sin escribir los scripts
Un simulador sigue necesitando scripts: algo tiene que sumar las monedas, comprobar los precios y guardar. No tienes que escribirlos tú:
- Un kit de simulador de la Creator Store. Lee sus scripts antes de publicar, y comprueba que las monedas cambian solo en un Script del servidor, nunca en un LocalScript.
- Un plugin generador de simuladores. La misma comprobación vale para lo que cree.
- Un agente de IA en Studio, como RoCode, que puede construir estos mismos tres scripts en tu place abierto.
- Build, en la app móvil de Roblox. La documentación de Roblox dice que crea juegos 2D y 2.5D más simples, como clickers, a partir de una descripción, y que se está lanzando poco a poco por región.
Uses lo que uses, haz las pruebas del Paso 5 y las comprobaciones de exploits de Por qué el servidor decide cada número sobre el resultado.
Cómo ampliarlo: mascotas, zonas, auto-click y leaderboards
Mascotas como multiplicadores
Un diseño común hace de cada mascota un multiplicador. Guarda la lista de ids de mascotas que tiene el jugador en su tabla guardada, y haz que el servidor multiplique clickValue por el bonus de cada mascota equipada. Abre los huevos en el servidor: el cliente pide abrir un huevo, y el servidor comprueba y cobra el precio, y luego elige la mascota con una tirada aleatoria ponderada. Nunca dejes que el cliente tire el huevo ni diga qué mascota le salió. La guía de inventario muestra cómo tener, guardar y mostrar objetos, y las mascotas funcionan igual. La guía de abrir huevos (en inglés) construye la tirada en el servidor, y la guía de mascotas que te siguen (en inglés) hace que las mascotas floten junto a su dueño.
Zonas que se desbloquean con rebirths
Una zona es un área del mapa con mejores recompensas detrás de una barrera. Bloquea la recompensa, no solo la puerta: lo que pague dentro de la zona debe comprobar los Rebirths del jugador en la tabla del servidor antes de pagar. Una puerta que abre un LocalScript para los jugadores que cumplen sirve para lo visual, pero los exploiters pueden cambiar partes y mover su personaje en su propio dispositivo.
Auto-click como game pass
Un auto-clicker que se vende como game pass debe ejecutarse en el servidor. Mueve el cuerpo del manejador de Click a una función como addClick(player), conecta el remote a ella y, para los dueños del pase, llámala desde un bucle del servidor con task.wait(0.5), no con el wait obsoleto. Así los auto-clics cuentan para el mismo límite por segundo que los clics manuales. Comprueba la propiedad en el servidor con MarketplaceService:UserOwnsGamePassAsync, como hace la guía de game pass (en inglés) para sus ventajas. Un pase de monedas x2 funciona igual: multiplica clickValue en el servidor para los dueños. Antes de ponerle precio, la calculadora de impuestos de Robux gratis (en inglés) muestra lo que te paga cada venta después de la parte de Roblox, y la calculadora de DevEx (en inglés) cuánto valen esos Robux en dólares estadounidenses.
Un top 10 global de rebirths
leaderstats solo compara jugadores del mismo servidor. Para clasificar los Rebirths de todos los jugadores, escríbelos en un ordered data store y lee las primeras entradas, como en el Paso 4 de la guía de leaderboard. Los ordered data stores permiten menos escrituras que los estándar, 30 + 5 × jugadores por minuto por servidor, así que escribe cuando un jugador sale y con un temporizador.
Números muy grandes
Los números de Luau son doubles, que guardan unas 15 cifras significativas. Un IntValue guarda números enteros hasta unos 9.2 trillones, pero Roblox avisa de que los valores por encima de 2^53 (unos 9 mil billones) pierden precisión en los scripts. Con estos ajustes el precio del rebirth pasa ese punto en el rebirth 29. Si tu juego llega más lejos, cambia los valores de leaderstats a NumberValue (cambia IntValue en los dos scripts), que guarda números mucho más grandes con la misma precisión de unas 15 cifras, y añade sufijos a short().
Qué hace que un juego simulador funcione
Un simulador es un juego de números. El clic, la mejora y el rebirth de arriba son todo el bucle; lo que decide si los jugadores se quedan es cómo crecen esos números. Cada pocos minutos el jugador debería poder pagar algo que haga más rápidos los minutos siguientes, y cada sesión debería terminar cerca de un objetivo por el que quiera volver.
- Un crecimiento que dure. Los precios de las mejoras crecen más rápido que los ingresos, así que cada nivel tarda un poco más. Un rebirth reinicia las monedas a cambio de un multiplicador permanente, que convierte un área vieja en una rápida y hace que la subida se sienta nueva.
- Cosas que coleccionar. Áreas que desbloquear, mascotas de huevos que multiplican lo que ganas y herramientas que mejorar dan a los jugadores una lista de objetivos más allá de un solo número.
- Números grandes que se sigan leyendo. Muestra 1.5M, no 1500000, y guarda los números de forma que el servidor pueda seguir comparándolos cuando se hacen grandes.
Monetización que encaja con un simulador
Los pases habituales multiplican las monedas, añaden un hueco extra para mascotas, abren más huevos a la vez o hacen auto-click. Véndelos como game passes y compruébalos en el servidor. Los paquetes de monedas son developer products. Si los huevos o cualquier cosa con un resultado aleatorio se pueden comprar con Robux, o con una moneda comprada con Robux, Roblox exige mostrar las probabilidades antes de la compra: lee paid random items (en inglés) antes de construir la tienda.
Qué hace volver a los jugadores
Progreso guardado, un área o un set de mascotas nuevo en cada actualización, recompensas diarias, códigos (en inglés) anunciados con las actualizaciones, y un leaderboard de rebirths. Más géneros, cada uno con su bucle, sus sistemas y su plan de construcción: géneros de juegos de Roblox (en inglés).
Errores comunes y soluciones
Abre la ventana Output (menú Window y luego Output) antes de pulsar Play. La mayoría de los problemas muestran ahí una advertencia o un error, con el nombre del script y la línea.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("SimulatorRemotes")'
El LocalScript está esperando los remotes, que SimulatorService crea cuando arranca. Comprueba que SimulatorService es un Script, no un LocalScript, que está dentro de ServerScriptService y que Output no muestra ningún error suyo. La misma advertencia para SimulatorConfig significa que el módulo no está en ReplicatedStorage o tiene otro nombre.
Los botones no aparecen nunca
El LocalScript espera a tus leaderstats antes de construir la pantalla. Si Output muestra Infinite yield possible en leaderstats, SimulatorService todavía no te ha preparado. Con SAVE_PROGRESS = true espera a PlayerData, así que comprueba que PlayerData está en ServerScriptService y carga sin errores.
Output dice "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"
El guardado está activado, pero el módulo PlayerData todavía no tiene los campos nuevos. Añádelos a sus DEFAULTS como en el Paso 4 y vuelve a pulsar Play.
Aparecen los "+1" pero mis monedas no suben
El servidor no está contando los clics. O SimulatorService tuvo un error (busca texto rojo suyo en Output), o los clics llegan más rápido de lo que permite MAX_CLICKS_PER_SECOND. Si los jugadores llegan al límite jugando normal, súbelo en SimulatorConfig.
La línea de estado dice "No answer from the server. Try again."
La llamada a BuyUpgrade o Rebirth falló en vez de devolver una respuesta. La causa habitual es un error dentro de SimulatorService mientras gestionaba la petición, así que busca un error rojo suyo en Output: indica la línea.
El contador de monedas en pantalla y la lista de jugadores muestran números distintos
Otro script también está creando una carpeta leaderstats, así que cada jugador tiene dos, y el LocalScript puede estar leyendo la otra. Borra el script extra: SimulatorService crea Coins y Rebirths por su cuenta.
Mis monedas se reinician cada vez que vuelvo a entrar
El guardado está desactivado. Sigue el Paso 4. Si está activado y las monedas se siguen reiniciando en Studio, comprueba que el acceso de Studio a los servicios de API está activado en tu copia de prueba, como explica el tutorial de DataStore.
Constrúyelo con RoCode
Si prefieres no pegar esto a mano, RoCode puede construirlo en el place que tienes abierto. Es un agente de programación con IA independiente, no lo hace Roblox: describes el sistema en su chat web y su plugin de Roblox Studio crea los scripts en tu Explorer, así que no copias código de una ventana de chat.
Haz un simulador clicker: un botón Click grande que dé monedas igual a mi nivel de Click Power por (rebirths + 1), un botón Upgrade que cueste 10 monedas y crezca 1.5 veces cada nivel, y un botón Rebirth a 1,000 monedas que reinicie monedas y mejoras. Deja los números en el servidor y limita los clics a 15 por segundo. Ya tengo un módulo PlayerData.
- Puede leer primero tu módulo PlayerData y cualquier script de leaderstats con Search Scripts y Read Script, para añadir campos a tus datos actuales en vez de escribir un segundo script de guardado
- Puede montar la pantalla con el diseño HUD de Build UI (con el plugin 3.9 o posterior, en su estilo de simulador), o construir los botones en un LocalScript, y escribe el ModuleScript, el Script del servidor y el LocalScript con Create Script
- Tiene la instrucción de comprobar que cada script que escribe compila con Check Script, que lo compila en Studio sin ejecutarlo
- Pone un punto de deshacer antes y después de cada lote de cambios, así que Ctrl+Z retrocede un lote cada vez
RoCode no puede crear game passes ni developer products, ni subir meshes e iconos de mascotas: eso hazlo en Creator Hub y en Studio. Con el plugin 3.9.11 o posterior, RoCode puede hacer una prueba de tu juego en Studio y controlar un personaje de prueba para comprobar que funciona, y con el plugin 3.9.15 o posterior el personaje de prueba puede pulsar botones en pantalla, por ejemplo pulsar Click y comprobar que Coins subió. Decide cuándo hacer una prueba, hasta 2 por construcción más 1 para comprobar su propio arreglo, y solo comprueba lo que eligió probar, así que prueba el bucle tú mismo. Un simulador entero son varios prompts, un sistema cada vez: cómo funciona construir un sistema por prompt con RoCode (en inglés). Cómo se conecta RoCode a Studio.
Preguntas frecuentes
¿Cómo hago un simulador en Roblox sin saber programar?
Un simulador que funcione necesita scripts: algo tiene que sumar monedas, comprobar precios y guardar el progreso. Puedes pegar los tres scripts de esta guía tal cual y cambiar solo los números de SimulatorConfig, o dejar que los haga un kit de la Creator Store, un plugin o un agente de IA y comprobar que el servidor decide las monedas. Las opciones.
¿Cómo funciona un sistema de rebirth?
Un rebirth cambia tus monedas y mejoras por un bonus permanente. En esta guía el primer rebirth cuesta 1,000 monedas; pone Coins en 0 y Click Power en el nivel 1 y suma 1 a Rebirths, y a partir de ahí cada clic se multiplica por Rebirths + 1. Cada rebirth cuesta el triple que el anterior.
¿Cómo hago un simulador de fuerza o de levantar pesas?
Dale a los jugadores una Tool, como una mancuerna, cuyo LocalScript dispare el mismo remote Click en Tool.Activated. El servidor calcula la recompensa igual que con un clic de botón. Baja el límite de clics del servidor al ritmo de levantamiento para que un script no gane más que un jugador. La versión de levantar pesas tiene el script.
¿Qué sistemas necesita un juego simulador?
Primero el bucle de ganar, mejorar y rebirth, luego el guardado, luego mascotas u otra colección que multiplique lo que ganas, zonas que se desbloquean con rebirths, leaderboards, recompensas diarias y códigos, y al final los game passes. El orden de construcción enlaza una guía para cada uno.
¿Cuánto debería tardar un rebirth?
Lo bastante para que los jugadores compren varias mejoras antes, y lo bastante poco para que una primera sesión llegue a uno. Con los números de esta guía el primer rebirth llega tras unos 1.2 minutos a 5 clics por segundo; subir REBIRTH_BASE_COST a 10,000 lo deja en unos 8 minutos. La tabla de ritmo muestra más ajustes.
¿Cómo evito los auto clickers?
El servidor cuenta como máximo 15 clics por jugador en cada ventana de un segundo e ignora el resto. Por debajo de ese límite un script se ve igual que un jugador rápido, así que el límite es lo que protege tu economía. También puedes vender el auto-click como un game pass que se ejecuta en el servidor.
¿Por qué se reinician mis monedas cuando vuelvo a entrar?
Todavía nada las guarda. Añade el módulo PlayerData del tutorial de DataStore, añade PowerLevel y Rebirths a sus DEFAULTS y pon SAVE_PROGRESS = true en SimulatorService, como en el Paso 4.
¿Cómo pongo mascotas en mi simulador?
Haz de cada mascota un multiplicador que el servidor aplica a los clics. Abre los huevos en el servidor con una elección aleatoria ponderada, guarda los ids de las mascotas del jugador con el resto de sus datos y muéstralas con una GUI de inventario como la de la guía de inventario.
¿Los jugadores deberían hacer clic en una parte o en un botón?
Sirven los dos. Un botón en pantalla va bien en teléfonos, y una parte con un ClickDetector va bien en un juego ambientado en el mundo. La documentación de Roblox dice que el servidor no hace ninguna comprobación en los eventos de ClickDetector, así que limita también el ritmo de esos clics en el servidor de la misma manera.
Fuentes y lecturas
- Roblox Creator Docs: Securing the client-server boundary (en inglés). límites de ritmo, el ejemplo de la tienda en el juego y los eventos de ClickDetector
- Roblox Creator Docs: Security and cheat mitigation tactics (en inglés). qué controla un exploiter en su propio dispositivo
- Roblox Creator Docs: Remote events and callbacks (en inglés). FireServer, el parámetro del jugador, InvokeServer y OnServerInvoke
- Roblox Creator Docs: Leaderboards (en inglés). leaderstats y ordered data stores
- Roblox Creator Docs: Data store error codes and limits (en inglés). límites de escritura por servidor para data stores estándar y ordenados
- Roblox Engine API: GuiButton (en inglés). Activated en ordenador, móvil y consola
- Roblox Engine API: GuiService (en inglés). AutoSelectGuiEnabled y seleccionar objetos de GUI con un mando
- Roblox Engine API: IntValue (en inglés). el rango de 64 bits y la pérdida de precisión por encima de 2^53
- Roblox Creator Docs: Size modifiers and constraints (en inglés). UIAspectRatioConstraint y UISizeConstraint
- Roblox Creator Docs: Studio testing modes (en inglés). Device Simulator y Controller Emulator
Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 14 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.