Tutoriel · Systèmes de jeu

Comment faire un jeu simulator sur Roblox

La plupart des jeux simulator tournent sur la même boucle : faire quelque chose de simple pour gagner une monnaie, la dépenser en améliorations qui en rapportent plus vite, puis faire un rebirth pour recommencer avec un multiplicateur permanent. Ce guide construit cette boucle sous forme de clicker en trois scripts, avec le serveur qui décide de chaque nombre, et la sauvegarde avec le module PlayerData du tutoriel DataStore. Si tu n'as jamais fait de jeu dans Studio, fais d'abord un petit parcours à pièces.

Mis à jour le 14 novembre 202629 min de lectureÉcrit par

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
  1. Fonctionnement
  2. 1. Module de config
  3. 2. Script serveur
  4. 3. Boutons
  5. 4. Sauvegarder
  6. Pourquoi le serveur décide
  7. 5. Tester
  8. Version musculation
  9. Ordre de création
  10. Sans scripter
  11. Aller plus loin
  12. Le genre
  13. Problèmes courants
  14. Avec RoCode
  15. Questions fréquentes
  16. Sources et lectures

Comment marche la boucle principale d'un simulator

Illustration animéeLe joueur achète le niveau 2 de Click Power pour 10 pièces, puis (en accéléré) atteint 1 000 pièces et fait un rebirth : les pièces et les améliorations repartent à zéro et chaque clic vaut x2.

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.

Les trois actions de la boucle de ce guide
ActionCe qu'elle coûteCe qu'elle donneQui décide
ClickRienDes pièces égales à Click Power × (Rebirths + 1)Le serveur, qui compte au maximum 15 clics dans chaque fenêtre d'une seconde
Upgrade10 pièces, puis 1,5 fois le dernier prix pour chaque niveauUn niveau de Click Power en plus, jusqu'au niveau 50Le serveur, avec sa propre copie des prix
Rebirth1 000 pièces, puis 3 fois le dernier prix pour chaque rebirthPièces remises à 0 et Click Power remise au niveau 1, plus un +1 permanent au multiplicateurLe 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.

Les éléments du simulator
ÉlémentOù il se trouveCe qu'il fait
Le ModuleScript SimulatorConfigReplicatedStorageLes 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 SimulatorServiceServerScriptServiceGarde les nombres de chaque joueur, gère les clics, les améliorations et les rebirths, et remplit leaderstats.
Le Folder SimulatorRemotesReplicatedStorage (SimulatorService le crée)Le RemoteEvent Click et les RemoteFunctions BuyUpgrade et Rebirth.
Le LocalScript SimulatorClientStarterPlayerScriptsConstruit les boutons, envoie les clics et les demandes, et affiche les nombres du serveur.
Le ModuleScript PlayerData (facultatif)ServerScriptServiceSauvegarde la progression entre les visites. Il vient du tutoriel DataStore et ne sert qu'à l'étape 4.
L'Explorer pendant que le jeu tourne. SimulatorService crée SimulatorRemotes et ses trois remotes au démarrage du jeu, et PlayerData n'est là qu'une fois la sauvegarde ajoutée à 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.

  1. Dans l'Explorer, survole ReplicatedStorage, clique sur le bouton + et insère un ModuleScript.
  2. Renomme-le SimulatorConfig (les noms sont sensibles à la casse) et remplace son contenu par le code ci-dessous.
ModuleScript dans ReplicatedStorage nommé SimulatorConfig
-- 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.

Ce que donnent les formules avec ces réglages
Niveau de Click PowerPrix du niveau suivantPièces par clic, sans rebirthPièces par clic, 1 rebirth
11012
21524
32236
43348
550510

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.

Minutes depuis un départ à zéro jusqu'à chaque rebirth à 5 clics par seconde, selon REBIRTH_BASE_COST. Calculé à partir des formules de SimulatorConfig, pas mesuré sur des joueurs
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1 000 (ce guide)1,22,74,8
5 0004,310,118,3
10 0008,216,933,2
25 00016,740,174,5
50 00032,868,8137,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 :

Script dans ServerScriptService nommé SimulatorService
-- 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.

  1. Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts et insère un LocalScript nommé SimulatorClient.
  2. Remplace son contenu par le code ci-dessous et appuie sur Play.
LocalScript dans StarterPlayerScripts nommé SimulatorClient
-- 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 UIAspectRatioConstraint le garde carré et un UISizeConstraint le 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 à UNITS pour 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.

  1. 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 script Main du tutoriel pour ça.
  2. Dans PlayerData, ajoute PowerLevel = 1, et Rebirths = 0, dans la table DEFAULTS, à côté de Coins = 0,.
  3. Dans le même module, ajoute PowerLevel: number, et Rebirths: number, au type Data, pour que la vérification stricte des types connaisse les nouveaux champs.
  4. Dans SimulatorService, change local SAVE_PROGRESS = false en local 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.

Ce qu'un exploiteur peut tenter, et ce que fait SimulatorService
Un exploiteur essaie deSi le client décidaitCe que fait SimulatorService
Déclencher Click en boucle le plus vite possibleDes pièces à l'infiniCompte au maximum 15 clics dans chaque fenêtre d'une seconde et ignore le reste.
Envoyer un nombre de pièces avec le clicIl choisit sa propre récompenseIgnore tous les arguments. La valeur d'un clic vient des nombres du serveur.
Acheter une amélioration ou un rebirth sans assez de piècesDes améliorations gratuitesCompare le prix aux Coins du serveur et répond "You need N more coins."
Modifier Coins dans leaderstats sur son propre écranDépenser des pièces qu'il n'a pasNe lit jamais leaderstats. Il ne fait qu'y écrire, depuis sa propre table.
Régler l'attribut PowerLevel sur son PlayerUn clic plus grosNe lit jamais l'attribut, et le changement reste sur son appareil.
Appeler Rebirth deux fois au même momentDeux rebirths pour le prix d'unRevé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 SimulatorConfigDes améliorations moins chèresUtilise 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

Pratiques courantes dans les vieux tutoriels de clicker, et ce que fait ce guide à la place
PratiqueLe problèmeCe guide
Un LocalScript ajoute des pièces avec leaderstats.Coins.Value += 1Le changement reste sur cet appareil, et les exploiteurs contrôlent leur appareilLe serveur ajoute les pièces
clickEvent:FireServer(amount)Le client choisit sa propre récompenseClick n'envoie aucun argument
Pas de limite de fréquence sur le serveurLa doc de Roblox dit de ne jamais compter uniquement sur une limite côté clientAu maximum 15 clics dans chaque fenêtre d'une seconde
SetAsync à chaque clic ou améliorationÉpuise le budget d'écritures du serveurPlayerData 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 simulatorDeux 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 passifRoblox marque le wait global comme obsolète, remplacé par task.waittask.wait (vois Aller plus loin)
MouseButton1Click sur les boutonsDocumenté pour les clics de sourisActivated, 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.

  1. 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.
  2. Clique dix fois sur le bouton violet Click!. Chaque clic affiche un +1 doré, et Coins dans la liste des joueurs monte de 1.
  3. 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.
  4. Avant de recliquer, appuie sur Rebirth. La ligne de statut affiche "You need 1000 more coins to rebirth." et rien ne change.
  5. Pour essayer un rebirth sans faire 1 000 clics, arrête le test, change Coins = 0 en Coins = 1000 dans 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.
  6. Pour voir la limite de fréquence, règle MAX_CLICKS_PER_SECOND sur 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.
  7. 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.
  8. 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.
  9. 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.

  1. Dans l'Explorer, survole StarterPack, insère un Tool et nomme-le Dumbbell. Insère dedans une Part nommée Handle, donne-lui la forme d'un haltère et décoche Anchored, comme dans les étapes du Tool du guide de l'épée.
  2. Insère dans le Tool un LocalScript nommé LiftClient et colle le code ci-dessous.
  3. 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 dans StarterPack nommé LiftClient
-- 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_SECONDS ne 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, baisse MAX_CLICKS_PER_SECOND dans 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 = false juste après la ligne de SimulatorClient qui crée clickButton.
  • 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.

Un ordre de création pour un simulator Roblox, de la boucle principale vers l'extérieur
OrdreSystèmeGuidePourquoi à ce moment-là
1Gagner, améliorer, rebirthCe guideTout ce qui suit multiplie cette boucle, donc règle d'abord ses nombres avec le tableau de rythme.
2SauvegardeTutoriel DataStore, puis étape 4Une 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 multiplicateursFaire é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.
4Zones derrière les rebirthsAller plus loinUn endroit où aller après un rebirth, avec de meilleures récompenses vérifiées sur le serveur.
5ClassementsGuide du leaderboardUn top 10 mondial des rebirths donne un sens à la longue montée.
6Récompenses quotidiennes et codesRécompenses quotidiennes et codes (en anglais)Des raisons de revenir demain et après chaque mise à jour.
7Game passesGuide 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.

Tu écris

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.

RoCode fait
  • 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

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.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.