En bref
Un simulator Roblox, c'est une boucle : cliquer pour gagner des pièces, les dépenser en améliorations qui rapportent plus vite, puis faire un rebirth pour un multiplicateur permanent. Range les prix dans un ModuleScript dans ReplicatedStorage. Laisse un seul Script dans ServerScriptService posséder les Coins, la Click Power et les Rebirths de chaque joueur, compter au maximum 15 clics par seconde depuis un RemoteEvent Click, et vendre les améliorations et les rebirths via des RemoteFunctions après avoir vérifié le prix. Un LocalScript affiche les boutons Click, Upgrade et Rebirth. Avec les nombres de ce guide, un joueur qui clique 5 fois par seconde atteint le premier rebirth en environ 1,2 minute, et le tableau de rythme montre quoi changer pour une progression plus longue.
- Un clic n'envoie rien d'autre que le clic. Le serveur calcule ce qu'il vaut, donc un client modifié ne peut pas se donner de pièces.
- Sauvegarde toute la table avec un minuteur et quand les joueurs partent, jamais à chaque clic. Roblox autorise chaque serveur à faire 60 + 40 × joueurs écritures de data store par minute.
- Tu ne scriptes pas ? Un kit du Creator Store, un plugin ou un agent IA peut construire la même boucle. Vérifie que c'est le serveur qui décide des pièces : les options.
- Plutôt soulever des haltères ou miner qu'appuyer sur un bouton ? Un Tool peut déclencher le même remote Click : la version musculation. Ajoute ensuite des systèmes dans l'ordre de création plus bas.
Sur cette page
Comment marche la boucle principale d'un simulator
Un simulator est une boucle de trois actions. Le joueur fait quelque chose de simple encore et encore pour gagner une monnaie, la dépense en améliorations qui en rapportent plus vite, et quand les améliorations deviennent chères, fait un rebirth : il abandonne ses pièces et ses améliorations contre un bonus qui ne disparaît jamais, puis remonte plus vite. D'autres simulators remplacent le clic par de la musculation, du minage ou de la collecte, mais la boucle en dessous est la même.
| Action | Ce qu'elle coûte | Ce qu'elle donne | Qui décide |
|---|---|---|---|
| Click | Rien | Des pièces égales à Click Power × (Rebirths + 1) | Le serveur, qui compte au maximum 15 clics dans chaque fenêtre d'une seconde |
| Upgrade | 10 pièces, puis 1,5 fois le dernier prix pour chaque niveau | Un niveau de Click Power en plus, jusqu'au niveau 50 | Le serveur, avec sa propre copie des prix |
| Rebirth | 1 000 pièces, puis 3 fois le dernier prix pour chaque rebirth | Pièces remises à 0 et Click Power remise au niveau 1, plus un +1 permanent au multiplicateur | Le serveur |
Chaque nombre vit sur le serveur. L'appareil du joueur dessine les boutons et demande des choses ("j'ai cliqué", "je veux une amélioration") ; le serveur décide de ce que ça vaut et si ça peut se faire. Les scripts de clicker qui se font exploiter ajoutent souvent les pièces dans un LocalScript, ou laissent le client envoyer combien de pièces ajouter.
| Élément | Où il se trouve | Ce qu'il fait |
|---|---|---|
Le ModuleScript SimulatorConfig | ReplicatedStorage | Les prix, les limites et les formules pour la valeur d'un clic, le prix d'une amélioration et le prix d'un rebirth. Les deux côtés le lisent. |
Le Script SimulatorService | ServerScriptService | Garde les nombres de chaque joueur, gère les clics, les améliorations et les rebirths, et remplit leaderstats. |
Le Folder SimulatorRemotes | ReplicatedStorage (SimulatorService le crée) | Le RemoteEvent Click et les RemoteFunctions BuyUpgrade et Rebirth. |
Le LocalScript SimulatorClient | StarterPlayerScripts | Construit les boutons, envoie les clics et les demandes, et affiche les nombres du serveur. |
Le ModuleScript PlayerData (facultatif) | ServerScriptService | Sauvegarde la progression entre les visites. Il vient du tutoriel DataStore et ne sert qu'à l'étape 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
Étape 1 : mettre les prix et les formules dans un module
Chaque nombre que tu pourrais vouloir régler va dans un seul ModuleScript : ce que vaut un clic, ce que coûtent chaque amélioration et chaque rebirth, et la limite de clics. Le serveur s'en sert pour décider, et le LocalScript pour afficher les prix sur les boutons, donc un changement se fait en une modification à un seul endroit.
- Dans l'Explorer, survole ReplicatedStorage, clique sur le bouton + et insère un ModuleScript.
- Renomme-le
SimulatorConfig(les noms sont sensibles à la casse) et remplace son contenu par le code ci-dessous.
-- Tous les nombres de la boucle principale, et les formules que les deux côtés utilisent. Le client
-- s'en sert seulement pour afficher les prix ; le serveur décide avec sa propre copie.
local SimulatorConfig = {}
SimulatorConfig.UPGRADE_BASE_COST = 10 -- prix du niveau 2 de Click Power
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- chaque niveau coûte 1,5 fois le précédent
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- pièces nécessaires pour le premier rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- chaque rebirth coûte 3 fois le précédent
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- les clics au-delà de ce nombre en une seconde sont ignorés
-- Pièces pour un clic : le niveau de Click Power, multiplié par 1 + le nombre de rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
return powerLevel * (rebirths + 1)
end
-- Prix du prochain niveau de Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end
-- Pièces nécessaires pour le prochain rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end
return SimulatorConfig
Les joueurs peuvent lire un ModuleScript dans ReplicatedStorage, donc ces prix sont publics. Ce n'est pas grave : ils sont de toute façon sur les boutons. Le client et le serveur exécutent chacun leur propre copie du module, donc un joueur qui modifie les nombres sur son appareil ne change rien sur le serveur.
| Niveau de Click Power | Prix du niveau suivant | Pièces par clic, sans rebirth | Pièces par clic, 1 rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
Les rebirths coûtent 1 000 pièces, puis 3 000, puis 9 000, parce que rebirthCost multiplie le prix par 3 à chaque fois. Après un rebirth, chaque clic vaut deux fois plus, après deux rebirths trois fois plus, et ainsi de suite.
Combien de temps prend un rebirth avec ces nombres
Les formules décident de la durée de la boucle, donc ça vaut le coup de faire les calculs avant les joueurs. Le tableau suppose un joueur qui fait un rebirth dès qu'il peut se le payer, et sinon achète le niveau suivant de Click Power dès qu'il peut se le payer et qu'il coûte moins cher que le rebirth. Les temps comptent depuis un départ à zéro, donc la dernière colonne est le temps total jusqu'à 3 rebirths.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1 000 (ce guide) | 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 |
Sans rebirth, le niveau 5 de Click Power arrive après 34 clics, le niveau 10 après 122 et le niveau 13 après 285. Avec les nombres par défaut, le joueur arrête alors d'acheter des améliorations, parce que le niveau 14 coûte 1 297 pièces, plus que le rebirth à 1 000 pièces, et le premier rebirth arrive après 362 clics au total. À la limite du serveur de 15 clics par seconde, divise chaque temps par 3. Change n'importe quel nombre dans SimulatorConfig et ces temps changent avec, donc refais le calcul.
Régler la croissance
Les deux nombres _GROWTH fixent la vitesse à laquelle les prix montent. À 1,5, chaque amélioration coûte moitié plus que la précédente, alors que chaque niveau n'ajoute qu'une pièce par clic (avant le multiplicateur de rebirth), donc chaque nouveau niveau met plus de temps à se rentabiliser. C'est ce ralentissement qui rend un rebirth intéressant. Monte la croissance pour une progression plus longue, baisse-la pour une plus rapide, et garde REBIRTH_BASE_COST assez haut pour que les joueurs achètent quelques améliorations avant leur premier rebirth.
Pour un premier rebirth après plusieurs minutes au lieu d'environ une, monte REBIRTH_BASE_COST à 5 000 ou 10 000.
Étape 2 : ajouter le script serveur
Ce Script possède chaque nombre. Il crée les remotes, donne à chaque joueur un dossier leaderstats avec Coins et Rebirths, et répond aux trois demandes. Survole ServerScriptService, insère un Script, renomme-le SimulatorService et remplace son contenu par ceci :
-- Possède tous les nombres : les clics rapportent des pièces ici, les améliorations et rebirths s'achètent ici,
-- et leaderstats ne fait qu'afficher le résultat.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- false : tout le monde repart de zéro à chaque visite. true : charger et sauvegarder avec le module PlayerData
-- du tutoriel DataStore (ajoute d'abord PowerLevel = 1 et Rebirths = 0 à ses 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 } = {} -- quand la fenêtre d'une seconde en cours de ce joueur a commencé
local clickCount: { [Player]: number } = {} -- clics comptés dans cette fenêtre
-- Copie les nombres du serveur dans ce que voient les joueurs : leaderstats et un attribut
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
-- Prépare un joueur avec les données reçues (des nombres neufs, ou une table sauvegardée)
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 ne transporte aucun nombre : le serveur calcule ce qu'il vaut
clickEvent.OnServerEvent:Connect(function(player: Player)
local data = playerStats[player]
if not data then
return
end
local now = os.clock()
local start = windowStart[player]
if not start or now - start >= 1 then
windowStart[player] = now
clickCount[player] = 0
end
local count = clickCount[player] or 0
if count >= Config.MAX_CLICKS_PER_SECOND then
return -- un autoclicker ou un script qui déclenche le remote en boucle
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 échange pièces et améliorations contre un multiplicateur permanent
data.Coins = 0
data.PowerLevel = 1
data.Rebirths += 1
refresh(player)
return true, `Rebirth {data.Rebirths}! Every click is now worth x{data.Rebirths + 1}.`
end
-- Nombres de départ : des neufs, ou la table que le module PlayerData charge et sauvegarde
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 même table que PlayerData sauvegarde, donc chaque changement est sauvegardé
end
PlayerData.Loaded:Connect(onLoaded)
for _, player in Players:GetPlayers() do
onLoaded(player) -- les joueurs dont les données ont chargé avant le démarrage de ce 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)
La Click Power arrive au joueur sous forme d'attribut PowerLevel sur son objet Player, pas comme troisième valeur de leaderstats, donc la liste des joueurs n'affiche que Coins et Rebirths. Les attributs que le serveur règle sont répliqués sur l'appareil du joueur ; un changement qu'un joueur fait sur son propre appareil reste là.
Les clics et la limite de fréquence
Le remote Click ne transporte aucun argument. Sur le serveur, le premier paramètre d'un gestionnaire OnServerEvent est toujours le joueur qui l'a déclenché, donc le serveur sait qui a cliqué, regarde son niveau de Click Power et ses Rebirths, et ajoute clickValue à ses Coins. Il n'y a rien dans la demande qu'un tricheur puisse changer.
Le guide de sécurité de Roblox dit de ne jamais compter uniquement sur une limite de fréquence côté client, et cite l'attribution de monnaie parmi les actions à limiter. Le serveur compte les clics de chaque joueur dans des fenêtres d'une seconde : le premier clic ouvre une fenêtre, et une fois 15 clics comptés, les suivants sont ignorés jusqu'à ce qu'une seconde soit passée depuis le début de la fenêtre. Un script qui déclenche le remote en boucle ne se fait pas compter plus de 15 clics dans chaque fenêtre. Pour autoriser des clics plus rapides ou plus lents, change MAX_CLICKS_PER_SECOND dans SimulatorConfig.
Les améliorations et les rebirths
BuyUpgrade et Rebirth sont des RemoteFunctions, donc le bouton peut attendre la réponse et l'afficher. Chaque gestionnaire lit le prix dans la copie de SimulatorConfig du serveur, vérifie les Coins du joueur, et seulement ensuite change quelque chose. Il renvoie true ou false et un message comme "You need 5 more coins.", que le LocalScript affiche dans une ligne de statut.
Rien n'attend ni ne cède la main (yield) entre la vérification du prix et le changement, donc deux demandes du même joueur ne peuvent pas passer toutes les deux la vérification avant que la première prenne les pièces. Un rebirth met Coins à 0 et Click Power au niveau 1 et ajoute 1 à Rebirths, que la formule du clic transforme en multiplicateur de Rebirths + 1.
L'interrupteur SAVE_PROGRESS
Avec SAVE_PROGRESS = false, chaque joueur repart de 0 pièce à chaque visite, ce que tu veux pendant que tu construis. L'étape 4 l'active. Le script attend alors que le module PlayerData charge chaque joueur et travaille directement sur la table que ce module sauvegarde, donc chaque pièce et chaque rebirth est sauvegardé sans code en plus.
Étape 3 : construire les boutons
Ce LocalScript construit tout l'écran en code : le compteur de pièces en haut, un grand bouton Click au milieu, les boutons Upgrade et Rebirth en bas, et une ligne de statut pour les réponses du serveur. Il ne change jamais un nombre lui-même.
- Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts et insère un LocalScript nommé
SimulatorClient. - Remplace son contenu par le code ci-dessous et appuie sur Play.
-- Construit les boutons du simulator et affiche les nombres du serveur. Il ne les change jamais.
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))
-- Garde le bouton Click carré, à la taille de l'écran et jamais plus grand que 200 sur 200,
-- pour que sur un téléphone il tienne entre le compteur de pièces et les boutons du bas
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" qui monte depuis le bouton. Le nombre est une estimation, juste pour l'affichage ;
-- le serveur décide de ce que le clic vaut vraiment.
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)
Les boutons utilisent Activated, que Roblox déclenche pour un clic gauche sur ordinateur, un toucher sur mobile, et A (ou croix) sur une manette en mode de navigation dans l'interface.
Sur une manette, A n'appuie que sur un bouton sélectionné. Avec GuiService.AutoSelectGuiEnabled activé, le bouton Select de la manette sélectionne tes boutons à l'écran ; les joueurs peuvent alors passer de l'un à l'autre et appuyer sur A. Si tu préfères qu'un bouton de manette clique tout de suite, associe-en un avec ContextActionService et déclenche depuis lui le même remote Click.
Quatre détails dans le script :
- Le bouton Click s'adapte à l'écran. Sa taille est une fraction de l'écran, un
UIAspectRatioConstraintle garde carré et unUISizeConstraintle limite à 200 sur 200 pixels. Sur un écran d'ordinateur il fait 200 pixels de large ; sur un téléphone il rétrécit pour tenir entre le compteur de pièces et les boutons du bas. Garde-le à distance de ces boutons si tu déplaces des choses : Rebirth n'a pas de confirmation, donc un toucher de travers à cet endroit peut remettre à zéro les pièces et les améliorations du joueur. - Le "+N" n'est là que pour l'affichage. Il utilise la copie de la formule du client. Si le serveur ignore un clic à cause de la limite de fréquence, le "+N" apparaît quand même, mais les pièces ne changent pas.
short()garde les grands nombres lisibles. 1 234 s'affiche 1.2K et 5 600 000 s'affiche 5.6M. Il arrondit vers le bas, donc le compteur n'affiche jamais plus que ce que tu as. Ajoute des entrées àUNITSpour les nombres au-delà de T (les billions).- L'écran se met à jour avec des événements. Il écoute les valeurs Coins et Rebirths et l'attribut PowerLevel, donc les prix des boutons sont justes quelle que soit la façon dont les nombres changent.
Le ScreenGui a ResetOnSpawn réglé sur false, donc il reste quand le personnage réapparaît. C'est important ici : un LocalScript dans StarterPlayerScripts n'est copié au joueur qu'une fois, quand il rejoint, donc il ne reconstruirait pas l'écran.
Étape 4 : sauvegarder la progression avec PlayerData
Jusqu'ici, tout repart à zéro quand un joueur part. Plutôt que d'ajouter un deuxième script de sauvegarde, le simulator se branche sur le module PlayerData du tutoriel DataStore. Ce module réessaie déjà les requêtes qui échouent, sauvegarde automatiquement toutes les 180 secondes, sauvegarde quand un joueur part et quand le serveur s'arrête, et ne sauvegarde jamais un joueur dont les données n'ont pas pu charger.
- Suis l'étape 1 du tutoriel DataStore pour ajouter le ModuleScript
PlayerDataà ServerScriptService. Pour tester la sauvegarde dans Studio, active l'accès de Studio aux services d'API dans une copie de test de ton jeu, comme l'explique sa première partie. SimulatorService fait lui-même le require du module, donc tu n'as pas besoin du scriptMaindu tutoriel pour ça. - Dans PlayerData, ajoute
PowerLevel = 1,etRebirths = 0,dans la tableDEFAULTS, à côté deCoins = 0,. - Dans le même module, ajoute
PowerLevel: number,etRebirths: number,au typeData, pour que la vérification stricte des types connaisse les nouveaux champs. - Dans SimulatorService, change
local SAVE_PROGRESS = falseenlocal SAVE_PROGRESS = true.
Les joueurs qui avaient sauvegardé avant que tu ajoutes les champs les reçoivent automatiquement : la fonction migrate de PlayerData remplit tout champ de DEFAULTS absent d'une table sauvegardée, donc ils commencent au niveau 1 de Click Power avec 0 rebirth et gardent leurs Coins. Si tu sautes l'étape 2, SimulatorService affiche un avertissement qui dit quels champs ajouter et ne prépare pas le joueur.
Pourquoi le simulator écrit dans la table de PlayerData
Avec la sauvegarde activée, SimulatorService ne copie les nombres nulle part. PlayerData.Get(player) renvoie la table vivante que le module sauvegarde, et le simulator change Coins, PowerLevel et Rebirths dans cette même table. Il y a une seule copie de chaque nombre et un seul script qui écrit dans le data store. Deux scripts qui sauvegardent la même clé s'écrasent l'un l'autre, et l'un d'eux peut sauvegarder des nombres plus anciens par-dessus ceux de l'autre.
Ne crée pas non plus leaderstats dans un gestionnaire Loaded, comme le tutoriel DataStore le propose pour d'autres jeux : SimulatorService crée déjà Coins et Rebirths à partir de la table chargée. Si un script de leaderboard crée déjà leaderstats, supprime-le.
Pourquoi ne pas sauvegarder à chaque clic
Roblox autorise chaque serveur à faire 60 + 40 × joueurs écritures de data store standard par minute (le tableau des limites du tutoriel DataStore donne le reste). Sauvegarder à chaque clic à 15 clics par seconde ferait 900 écritures par minute pour un seul joueur, bien au-delà des 100 qu'obtient un serveur à un joueur. Sauvegarder toute la table toutes les 180 secondes, quand le joueur part et quand le serveur s'arrête, ne coûte que quelques écritures par joueur, et un crash fait perdre au plus la progression depuis la dernière sauvegarde automatique.
Si un chargement échoue, le module laisse le joueur jouer avec des nombres neufs mais ne les sauvegarde jamais, donc un mauvais chargement ne peut pas remplacer une vraie progression. Le tutoriel explique comment le module gère ça.
Pourquoi le serveur décide de chaque nombre
Les exploiteurs contrôlent leur propre appareil. Le guide de sécurité de Roblox dit qu'ils peuvent changer n'importe quoi dans leur copie locale du jeu, et déclencher ou appeler n'importe quel RemoteEvent ou RemoteFunction aussi souvent qu'ils veulent avec n'importe quels arguments. L'économie d'un simulator n'est sûre qu'autant que son script serveur.
| Un exploiteur essaie de | Si le client décidait | Ce que fait SimulatorService |
|---|---|---|
| Déclencher Click en boucle le plus vite possible | Des pièces à l'infini | Compte au maximum 15 clics dans chaque fenêtre d'une seconde et ignore le reste. |
| Envoyer un nombre de pièces avec le clic | Il choisit sa propre récompense | Ignore tous les arguments. La valeur d'un clic vient des nombres du serveur. |
| Acheter une amélioration ou un rebirth sans assez de pièces | Des améliorations gratuites | Compare le prix aux Coins du serveur et répond "You need N more coins." |
| Modifier Coins dans leaderstats sur son propre écran | Dépenser des pièces qu'il n'a pas | Ne lit jamais leaderstats. Il ne fait qu'y écrire, depuis sa propre table. |
| Régler l'attribut PowerLevel sur son Player | Un clic plus gros | Ne lit jamais l'attribut, et le changement reste sur son appareil. |
| Appeler Rebirth deux fois au même moment | Deux rebirths pour le prix d'un | Revérifie le prix à chaque appel, et rien ne cède la main entre la vérification et le changement. |
| Changer les prix dans sa copie de SimulatorConfig | Des améliorations moins chères | Utilise sa propre copie du module. |
La règle vaut pour chaque remote d'un simulator : envoie ce que le joueur veut faire, jamais ce que ça vaut. Le guide des RemoteEvents explique plus en détail comment valider les arguments d'un remote.
Les pratiques à éviter dans les scripts de clicker copiés
| Pratique | Le problème | Ce guide |
|---|---|---|
Un LocalScript ajoute des pièces avec leaderstats.Coins.Value += 1 | Le changement reste sur cet appareil, et les exploiteurs contrôlent leur appareil | Le serveur ajoute les pièces |
clickEvent:FireServer(amount) | Le client choisit sa propre récompense | Click n'envoie aucun argument |
| Pas de limite de fréquence sur le serveur | La doc de Roblox dit de ne jamais compter uniquement sur une limite côté client | Au maximum 15 clics dans chaque fenêtre d'une seconde |
SetAsync à chaque clic ou amélioration | Épuise le budget d'écritures du serveur | PlayerData sauvegarde toutes les 180 secondes, au départ du joueur et à l'arrêt du serveur. Sauvegarde tout de suite avec PlayerData.SaveNow seulement après quelque chose qui ne doit pas être perdu, comme un achat en Robux. |
| Un deuxième script de data store rien que pour le simulator | Deux scripts qui sauvegardent une même clé s'écrasent l'un l'autre | Écrit dans la table de PlayerData |
Des boucles while wait(1) do pour un revenu passif | Roblox marque le wait global comme obsolète, remplacé par task.wait | task.wait (vois Aller plus loin) |
MouseButton1Click sur les boutons | Documenté pour les clics de souris | Activated, pour la souris, le tactile et la manette |
Étape 5 : le tester
Fais les étapes 1 à 8 avec SAVE_PROGRESS = false dans SimulatorService, pour que chaque test parte de nombres neufs. Si tu as déjà activé la sauvegarde à l'étape 4, remets-la sur false pour l'instant et de nouveau sur true pour l'étape 9.
- Appuie sur Play. En haut de l'écran, on lit 0 coins, le bouton vert affiche Upgrade: 10 et l'orange affiche Rebirth: 1.0K.
- Clique dix fois sur le bouton violet Click!. Chaque clic affiche un +1 doré, et Coins dans la liste des joueurs monte de 1.
- Appuie sur Upgrade. Les pièces retombent à 0, la ligne de statut passe au vert avec "Click Power is now level 2." et le bouton affiche maintenant Upgrade: 15. À partir de là, chaque clic donne 2 pièces.
- Avant de recliquer, appuie sur Rebirth. La ligne de statut affiche "You need 1000 more coins to rebirth." et rien ne change.
- Pour essayer un rebirth sans faire 1 000 clics, arrête le test, change
Coins = 0enCoins = 1000dans la ligne vers le bas de SimulatorService qui prépare les nouveaux joueurs, et appuie sur Play. Appuie sur Rebirth : Coins passe à 0, Rebirths dans la liste des joueurs passe à 1, la ligne de statut affiche "Rebirth 1! Every click is now worth x2." et le bouton affiche maintenant Rebirth: 3.0K. Chaque clic donne maintenant 2 pièces au niveau 1 de Click Power. Remets la ligne à 0 ensuite. - Pour voir la limite de fréquence, règle
MAX_CLICKS_PER_SECONDsur 2 dans SimulatorConfig et clique vite. Les "+N" continuent d'apparaître, mais les Coins montent au maximum de la valeur de 2 clics par seconde. Remets-le à 15. - Choisis un téléphone dans le Device Simulator de Studio (une bêta de Studio ; l'ancien Device Emulator marche aussi) et appuie sur Play. Vérifie que le bouton Click ne recouvre ni le compteur de pièces ni les boutons Upgrade et Rebirth, et que la ligne de statut reste bien visible à côté quand tu appuies sur Upgrade.
- Branche une manette, ou ouvre le Controller Emulator de Studio (Controller, dans l'onglet Emulation) pendant le test, appuie sur Select, et vérifie que tu peux atteindre les trois boutons et les presser avec A.
- Avec la sauvegarde activée (étape 4) et de nouveau
SAVE_PROGRESS = true, gagne quelques pièces, appuie sur Stop, puis de nouveau sur Play. Tes Coins, ton niveau de Click Power et tes Rebirths reviennent.
En faire un simulator de musculation ou de minage
Beaucoup de simulators remplacent le bouton par une action dans le monde : soulever un haltère, donner un coup de pioche, donner un coup d'épée dans le vide. En dessous, c'est le même clic. Un Tool peut déclencher le même remote Click, donc SimulatorService, ses prix et sa limite de fréquence restent exactement comme ils sont.
- Dans l'Explorer, survole StarterPack, insère un Tool et nomme-le
Dumbbell. Insère dedans une Part nomméeHandle, donne-lui la forme d'un haltère et décoche Anchored, comme dans les étapes du Tool du guide de l'épée. - Insère dans le Tool un LocalScript nommé
LiftClientet colle le code ci-dessous. - Appuie sur Play, équipe l'haltère et clique. Les pièces montent de ta Click Power à chaque soulevé, exactement comme avec le bouton.
-- LocalScript dans le Tool Dumbbell, nommé LiftClient.
-- Chaque soulevé est un clic : il déclenche le même remote Click que le bouton, et le serveur
-- décide de ce qu'il vaut et combien comptent.
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 -- temps entre deux soulevés sur cet appareil ; le serveur a sa propre limite
local LIFT_ANIMATION_ID = "" -- facultatif : "rbxassetid://" suivi de l'id de ton animation
local player = Players.LocalPlayer
local lastLift = 0
local liftTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil
-- Charge l'animation de soulevé une fois par personnage, via l'Animator que Roblox a mis dans le 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() -- aucun argument : le serveur calcule la récompense
end)
Pour une animation de soulevé, crées-en une dans l'Animation Editor avec la priorité Action, publie-la et colle son ID dans LIFT_ANIMATION_ID. Les étapes d'animation du guide de l'épée marchent de la même façon.
- Adapte la limite du serveur à l'action.
LIFT_SECONDSne ralentit que les joueurs honnêtes : un tricheur peut déclencher Click depuis son propre code. Si soulever est la seule façon de gagner, baisseMAX_CLICKS_PER_SECONDdans SimulatorConfig au vrai rythme, par exemple 2 pour un soulevé toutes les 0,5 seconde, pour qu'un script ne puisse pas gagner plus qu'un joueur. Refais ensuite le tableau de rythme : chaque temps qu'il contient suppose 5 clics par seconde. - Garde ou cache le bouton. Le bouton Click marche toujours à côté du Tool. Pour le cacher, ajoute
clickButton.Visible = falsejuste après la ligne de SimulatorClient qui créeclickButton. - Ne gagner qu'au bon endroit. Pour ne payer que dans une salle de sport ou une mine, vérifie sur le serveur où se trouve le personnage avant de compter le clic, par exemple sa distance à une part de la zone. Une vérification dans LiftClient n'arrêterait personne.
Quoi construire ensuite : un ordre de création pour un simulator
Un simulator est une pile de systèmes posés sur cette boucle. Construis-les dans un ordre où chacun a quelque chose à multiplier, et teste après chacun. Voici l'ordre que nous conseillons, avec le guide de chaque étape.
| Ordre | Système | Guide | Pourquoi à ce moment-là |
|---|---|---|---|
| 1 | Gagner, améliorer, rebirth | Ce guide | Tout ce qui suit multiplie cette boucle, donc règle d'abord ses nombres avec le tableau de rythme. |
| 2 | Sauvegarde | Tutoriel DataStore, puis étape 4 | Une progression qui repart à zéro quand on revient, c'est la fin d'un simulator. Ajoute-la avant tout ce que les joueurs pourraient perdre. |
| 3 | Œufs et pets comme multiplicateurs | Faire éclore des œufs (en anglais) et pets qui suivent (en anglais) | Le deuxième objectif à côté des pièces : quelque chose à collectionner qui fait valoir chaque clic plus cher. |
| 4 | Zones derrière les rebirths | Aller plus loin | Un endroit où aller après un rebirth, avec de meilleures récompenses vérifiées sur le serveur. |
| 5 | Classements | Guide du leaderboard | Un top 10 mondial des rebirths donne un sens à la longue montée. |
| 6 | Récompenses quotidiennes et codes | Récompenses quotidiennes et codes (en anglais) | Des raisons de revenir demain et après chaque mise à jour. |
| 7 | Game passes | Guide des game pass (en anglais) | Pièces x2, auto-clic ou un emplacement de pet en plus, vérifiés sur le serveur. Vends-les une fois que la boucle gratuite est amusante. |
Pour les écrans, les kits d'interface Roblox gratuits (en anglais) contiennent des écrans de style simulator, avec les scripts qui les font marcher.
Faire un simulator sans écrire les scripts
Un simulator a quand même besoin de scripts : quelque chose doit ajouter les pièces, vérifier les prix et sauvegarder. Tu n'es pas obligé de les écrire toi-même :
- Un kit de simulator du Creator Store. Lis ses scripts avant de publier, et vérifie que les pièces ne changent que dans un Script serveur, jamais dans un LocalScript.
- Un plugin générateur de simulator. La même vérification vaut pour tout ce qu'il crée.
- Un agent IA dans Studio, comme RoCode, qui peut construire ces trois mêmes scripts dans le jeu que tu as ouvert. La partie RoCode plus bas contient une demande pour ce guide.
- Build, dans l'application mobile Roblox. La doc de Roblox dit qu'il fait des jeux 2D et 2.5D plus simples, comme des clickers, à partir d'une description, et qu'il arrive petit à petit selon les régions.
Quoi que tu utilises, fais sur le résultat les tests de l'étape 5 et les vérifications d'exploit de Pourquoi le serveur décide de chaque nombre.
Aller plus loin : pets, zones, auto-clic et classements
Les pets comme multiplicateurs
Un design courant fait de chaque pet un multiplicateur. Garde la liste des id des pets possédés dans la table sauvegardée du joueur, et fais multiplier clickValue par le serveur avec le bonus de chaque pet équipé. Fais éclore les œufs sur le serveur : le client demande à ouvrir un œuf, et le serveur vérifie et prend le prix, puis choisit le pet par un tirage aléatoire pondéré. Ne laisse jamais le client tirer l'œuf ou dire quel pet il a eu. Le guide de l'inventaire montre comment garder, sauvegarder et afficher des objets possédés, et les pets marchent de la même façon. Le guide pour faire éclore des œufs (en anglais) construit le tirage sur le serveur, et le guide des pets qui suivent (en anglais) fait flotter les pets à côté de leur propriétaire.
Des zones débloquées par les rebirths
Une zone est une partie de la carte avec de meilleures récompenses derrière une barrière. Verrouille la récompense, pas seulement la porte : tout ce qui paie dans la zone doit vérifier les Rebirths du joueur dans la table du serveur avant de payer. Une porte qu'un LocalScript ouvre pour les joueurs qui y ont droit, c'est bien pour le visuel, mais les exploiteurs peuvent changer des parts et déplacer leur personnage sur leur propre appareil.
L'auto-clic comme game pass
Un autoclicker vendu comme game pass doit tourner sur le serveur. Déplace le corps du gestionnaire de Click dans une fonction comme addClick(player), connecte le remote à cette fonction, et pour les détenteurs du pass appelle-la depuis une boucle serveur avec task.wait(0.5), pas avec le wait obsolète. Les auto-clics comptent alors dans la même limite par seconde que les clics à la main. Vérifie la possession sur le serveur avec MarketplaceService:UserOwnsGamePassAsync, comme le fait le guide des game pass (en anglais) pour ses avantages. Un pass pièces x2 marche de la même façon : multiplie clickValue sur le serveur pour ses détenteurs. Avant de fixer son prix, le calculateur de taxe Robux (en anglais) gratuit montre ce que chaque vente te rapporte après la part de Roblox, et le calculateur DevEx (en anglais) ce que valent ces Robux en dollars américains.
Un top 10 mondial des rebirths
leaderstats ne compare que les joueurs du même serveur. Pour classer les Rebirths de tous les joueurs, écris-les dans un ordered data store et relis les premières entrées, comme à l'étape 4 du guide du leaderboard. Les ordered data stores autorisent moins d'écritures que les standard, 30 + 5 × joueurs par minute et par serveur, donc écris quand un joueur part et avec un minuteur.
Les très grands nombres
Les nombres Luau sont des doubles, qui gardent environ 15 chiffres significatifs. Un IntValue contient des nombres entiers jusqu'à environ 9,2 trillions, mais Roblox précise que les valeurs au-delà de 2^53 (environ 9 billiards) perdent en précision dans les scripts. Avec ces réglages, le prix du rebirth dépasse ce point au 29e rebirth. Si ton jeu va plus loin, passe les valeurs de leaderstats en NumberValue (change IntValue dans les deux scripts), qui contient des nombres bien plus grands avec la même précision d'environ 15 chiffres, et ajoute des suffixes à short().
Ce qui fait marcher un jeu simulator
Un simulator est un jeu de nombres. Le clic, l'amélioration et le rebirth ci-dessus forment toute la boucle ; ce qui décide si les joueurs restent, c'est la façon dont ces nombres grandissent. Toutes les quelques minutes, le joueur devrait pouvoir s'offrir quelque chose qui rend les minutes suivantes plus rapides, et chaque session devrait se terminer près d'un objectif pour lequel il a envie de revenir.
- Une croissance qui dure. Les prix des améliorations montent plus vite que les revenus, donc chaque palier prend un peu plus longtemps. Un rebirth remet les pièces à zéro contre un multiplicateur permanent, ce qui rend une vieille zone rapide et donne l'impression d'une montée nouvelle.
- Des choses à collectionner. Des zones à débloquer, des pets issus d'œufs (en anglais) qui multiplient les gains, et des outils à améliorer donnent aux joueurs une liste d'objectifs au-delà d'un seul nombre.
- Des grands nombres qui restent lisibles. Affiche 1.5M, pas 1500000, et stocke des nombres que le serveur peut encore comparer quand ils deviennent grands.
Une monétisation adaptée à un simulator
Les passes courants multiplient les pièces, ajoutent un emplacement de pet, font éclore plus d'œufs à la fois ou cliquent tout seuls. Vends-les comme game passes et vérifie-les sur le serveur. Les packs de pièces sont des developer products. Si des œufs ou quoi que ce soit avec un résultat aléatoire peuvent s'acheter avec des Robux, ou avec une monnaie achetée avec des Robux, Roblox exige que les chances soient affichées avant l'achat : lis Paid random items (en anglais) avant de construire la boutique.
Ce qui fait revenir les joueurs
Une progression sauvegardée, une nouvelle zone ou une nouvelle série de pets dans les mises à jour, des récompenses quotidiennes, des codes (en anglais) annoncés avec les mises à jour, et un classement des rebirths. D'autres genres, chacun avec sa boucle, ses systèmes et son plan de création : les genres de jeux Roblox (en anglais).
Problèmes courants
Ouvre la fenêtre Output (menu Window, puis Output) avant d'appuyer sur Play. La plupart des problèmes y affichent un avertissement ou une erreur, avec le nom du script et la ligne.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("SimulatorRemotes")'
Le LocalScript attend les remotes, que SimulatorService crée à son démarrage. Vérifie que SimulatorService est un Script, pas un LocalScript, qu'il est dans ServerScriptService, et qu'Output n'affiche aucune erreur venant de lui. Le même avertissement pour SimulatorConfig veut dire que le module manque dans ReplicatedStorage ou porte un autre nom.
Les boutons n'apparaissent jamais
Le LocalScript attend tes leaderstats avant de construire l'écran. Si Output affiche Infinite yield possible sur leaderstats, SimulatorService ne t'a pas encore préparé. Avec SAVE_PROGRESS = true, il attend PlayerData, donc vérifie que PlayerData est dans ServerScriptService et charge sans erreur.
Output affiche "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"
La sauvegarde est activée, mais le module PlayerData n'a pas encore les nouveaux champs. Ajoute-les à ses DEFAULTS comme à l'étape 4 et appuie de nouveau sur Play.
Les "+1" apparaissent mais mes pièces ne montent pas
Le serveur ne compte pas les clics. Soit SimulatorService a rencontré une erreur (cherche du texte rouge venant de lui dans Output), soit les clics arrivent plus vite que ne l'autorise MAX_CLICKS_PER_SECOND. Si les joueurs atteignent la limite en jouant normalement, monte-la dans SimulatorConfig.
La ligne de statut affiche "No answer from the server. Try again."
L'appel à BuyUpgrade ou Rebirth a échoué au lieu de renvoyer une réponse. La cause habituelle est une erreur dans SimulatorService pendant qu'il traitait la demande, donc cherche une erreur rouge venant de lui dans Output : elle indique la ligne.
Le compteur de pièces à l'écran et la liste des joueurs n'affichent pas le même nombre
Un autre script crée aussi un dossier leaderstats, donc chaque joueur en a deux, et le LocalScript lit peut-être l'autre. Supprime le script en trop : SimulatorService crée Coins et Rebirths lui-même.
Mes pièces repartent à zéro à chaque fois que je reviens
La sauvegarde est désactivée. Suis l'étape 4. Si elle est activée et que les pièces repartent quand même à zéro dans Studio, vérifie que l'accès de Studio aux services d'API est activé dans ta copie de test, comme l'explique le tutoriel DataStore.
Le faire avec RoCode
Si tu préfères ne pas coller tout ça à la main, RoCode peut le construire dans le jeu que tu as ouvert. C'est un agent de code IA indépendant, qui n'est pas fait par Roblox : tu décris le système dans son chat web, et son plugin pour Roblox Studio crée les scripts dans ton Explorer, donc tu ne copies pas de code depuis une fenêtre de chat.
Fais un simulator clicker : un grand bouton Click qui donne autant de pièces que mon niveau de Click Power multiplié par (rebirths + 1), un bouton Upgrade qui coûte 10 pièces et augmente de 1,5 fois à chaque niveau, et un bouton Rebirth à 1 000 pièces qui remet à zéro les pièces et les améliorations. Garde les nombres sur le serveur et limite les clics à 15 par seconde. J'ai déjà un module PlayerData.
- Peut d'abord lire ton module PlayerData et tout script leaderstats avec Search Scripts et Read Script, pour ajouter des champs à tes données existantes au lieu d'écrire un deuxième script de sauvegarde
- Peut préparer l'écran avec la mise en page HUD de Build UI (avec le plugin 3.9 ou plus récent, dans son style simulator), ou construire les boutons dans un LocalScript, et écrit le ModuleScript, le Script serveur et le LocalScript avec Create Script
- A pour consigne de vérifier la compilation de chaque script qu'il écrit avec Check Script, qui le compile dans Studio sans le lancer
- Place un point d'annulation avant et après chaque lot de changements, donc Ctrl+Z revient en arrière un lot à la fois
RoCode ne peut pas créer de game passes ni de developer products, ni importer des meshes et des icônes de pets : fais-le dans le Creator Hub et dans Studio. Avec le plugin 3.9.11 ou plus récent, RoCode peut tester ton jeu dans Studio et contrôler un personnage de test pour vérifier qu'il marche, et avec le plugin 3.9.15 ou plus récent le personnage de test peut cliquer sur les boutons à l'écran, par exemple appuyer sur Click et vérifier que les Coins ont monté. Il décide quand lancer un test, jusqu'à 2 par construction plus 1 pour vérifier sa propre correction, et ne vérifie que ce qu'il a choisi de tester, donc teste la boucle toi-même aussi. Un simulator entier, c'est plusieurs demandes, un système à la fois : comment marche la construction d'un système par demande avec RoCode. Comment RoCode se connecte à Studio.
Questions fréquentes
Comment faire un jeu simulator sur Roblox sans scripter ?
Un simulator qui marche a besoin de scripts : quelque chose doit ajouter les pièces, vérifier les prix et sauvegarder la progression. Tu peux coller les trois scripts de ce guide tels quels et ne changer que les nombres dans SimulatorConfig, ou laisser un kit du Creator Store, un plugin ou un agent IA les créer et vérifier que c'est le serveur qui décide des pièces. Les options.
Comment marche un système de rebirth ?
Un rebirth échange tes pièces et tes améliorations contre un bonus permanent. Dans ce guide, le premier rebirth coûte 1 000 pièces ; il met Coins à 0 et Click Power au niveau 1 et ajoute 1 à Rebirths, et chaque clic est ensuite multiplié par Rebirths + 1. Chaque rebirth coûte trois fois plus que le précédent.
Comment faire un simulator de force ou de musculation ?
Donne aux joueurs un Tool, comme un haltère, dont le LocalScript déclenche le même remote Click sur Tool.Activated. Le serveur calcule la récompense exactement comme pour un clic sur le bouton. Baisse la limite de clics du serveur au rythme des soulevés pour qu'un script ne puisse pas gagner plus qu'un joueur. La version musculation contient le script.
De quels systèmes un jeu simulator a-t-il besoin ?
D'abord la boucle gagner, améliorer et rebirth, puis la sauvegarde, puis des pets ou une autre collection qui multiplie les gains, des zones débloquées par les rebirths, des classements, des récompenses quotidiennes et des codes, et en dernier les game passes. L'ordre de création donne un guide pour chacun.
Combien de temps devrait prendre un rebirth ?
Assez longtemps pour que les joueurs achètent d'abord plusieurs améliorations, assez peu pour qu'une première session en atteigne un. Avec les nombres de ce guide, le premier rebirth arrive après environ 1,2 minute à 5 clics par seconde ; monter REBIRTH_BASE_COST à 10 000 le fait passer à environ 8 minutes. Le tableau de rythme montre d'autres réglages.
Comment bloquer les autoclickers ?
Le serveur compte au maximum 15 clics par joueur dans chaque fenêtre d'une seconde et ignore le reste. Sous cette limite, un script ressemble à un joueur rapide, donc c'est la limite qui protège ton économie. Tu peux aussi vendre l'auto-clic comme game pass qui tourne sur le serveur.
Pourquoi mes pièces repartent à zéro quand je reviens ?
Rien ne les sauvegarde encore. Ajoute le module PlayerData du tutoriel DataStore, ajoute PowerLevel et Rebirths à ses DEFAULTS, et règle SAVE_PROGRESS = true dans SimulatorService, comme à l'étape 4.
Comment ajouter des pets à mon simulator ?
Fais de chaque pet un multiplicateur que le serveur applique aux clics. Fais éclore les œufs sur le serveur avec un tirage aléatoire pondéré, sauvegarde les id des pets possédés avec le reste des données du joueur, et affiche-les avec une interface d'inventaire comme celle du guide de l'inventaire.
Les joueurs doivent-ils cliquer sur une part ou sur un bouton ?
Les deux marchent. Un bouton à l'écran convient aux téléphones, et une part avec un ClickDetector convient à un jeu qui se passe dans le monde. La doc de Roblox dit que le serveur ne fait aucune vérification sur les événements de ClickDetector, donc limite ces clics sur le serveur de la même façon.
Sources et lectures
- Roblox Creator Docs : Securing the client-server boundary (en anglais). la limite de fréquence, l'exemple de boutique en jeu et les événements de ClickDetector
- Roblox Creator Docs : Security and cheat mitigation tactics (en anglais). ce qu'un exploiteur contrôle sur son propre appareil
- Roblox Creator Docs : Remote events and callbacks (en anglais). FireServer, le paramètre player, InvokeServer et OnServerInvoke
- Roblox Creator Docs : Leaderboards (en anglais). leaderstats et les ordered data stores
- Roblox Creator Docs : Data store error codes and limits (en anglais). les limites d'écriture par serveur pour les data stores standard et ordered
- Roblox Engine API : GuiButton (en anglais). Activated sur ordinateur, mobile et console
- Roblox Engine API : GuiService (en anglais). AutoSelectGuiEnabled et la sélection des objets GUI avec une manette
- Roblox Engine API : IntValue (en anglais). la plage sur 64 bits et la perte de précision au-delà de 2^53
- Roblox Creator Docs : Size modifiers and constraints (en anglais). UIAspectRatioConstraint et UISizeConstraint
- Roblox Creator Docs : Studio testing modes (en anglais). Device Simulator et Controller Emulator
Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 14 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.