Útmutató · Játékrendszerek

Hogyan készíts szimulátor játékot Robloxban

Szinte minden szimulátor ugyanazon a cikluson pörög: csinálsz valami egyszerűt, és valutát kapsz, elköltöd fejlesztésekre, amelyek gyorsabban hozzák, aztán rebirth-et csinálsz, hogy egy állandó szorzóval kezdd újra. Ebben az útmutatóban ezt a ciklust egy háromscriptes kattintós játékként építjük meg, ahol minden számot a szerver dönt el, az előrehaladást pedig a DataStore útmutató PlayerData moduljával mentjük. Ha még soha nem készítettél játékot a Studióban, előbb készíts egy rövid pályát érmékkel.

Frissítve 2026. november 20.25 perc olvasásSzerző:

Röviden

Egy Roblox szimulátor egyetlen ciklus: kattints, hogy érméket kapj, költsd el őket fejlesztésekre, amelyek többet adnak, aztán csinálj rebirth-et egy állandó szorzóért. Az árakat egy ModuleScriptben tartsd a ReplicatedStorage-ban. Egyetlen Script a ServerScriptService-ben tárolja minden játékos Coins, Click Power és Rebirths értékét, másodpercenként legfeljebb 15 kattintást számol be a Click RemoteEventtől, és az ár ellenőrzése után RemoteFunctionön keresztül adja el a fejlesztéseket és a rebirth-öket. Egy LocalScript mutatja a Click, Upgrade és Rebirth gombokat. Az útmutató számaival az a játékos, aki másodpercenként 5-öt kattint, nagyjából 1,2 perc alatt jut el az első rebirth-ig, a tempótáblázat pedig megmutatja, mit változtass, hogy hosszabb legyen a felfutás.

  • A kattintás semmit sem küld át, csak magát a kattintást. Hogy mennyit ér, azt a szerver számolja, ezért egy módosított kliens nem írhat jóvá magának érméket.
  • Az egész táblát időzítővel és a játékos kilépésekor mentsd, ne minden kattintásnál. A Roblox szerverenként percenként 60 + 40 × játékosok írást enged az adattárba.
  • Nem tudsz scriptelni? Ugyanezt a ciklust összerakhatja egy Creator Store csomag, egy plugin vagy egy AI-ügynök. Ellenőrizd, hogy az érméket a szerver dönti el: lehetőségek.
  • Edzőterem vagy bánya kell gomb helyett? Egy Tool ugyanazt a Click remote-ot hívhatja: súlyzós változat. Utána add hozzá a rendszereket az alábbi építési sorrend szerint.
Ezen az oldalon
  1. Hogyan működik
  2. 1. Beállítási modul
  3. 2. Szerverscript
  4. 3. Gombok
  5. 4. Mentés
  6. Miért a szerver dönt
  7. 5. Teszt
  8. Súlyzós változat
  9. Építési sorrend
  10. Scriptelés nélkül
  11. Hogyan bővítsd
  12. Műfaj
  13. Common errors
  14. RoCode-dal
  15. Gyakori kérdések
  16. Források és további olvasnivaló

Hogyan épül fel a szimulátor fő ciklusa

IllusztrációA játékos 10 érméért megveszi a 2-es szintű Click Powert, aztán (gyorsítva) összegyűjt 1 000 érmét, és rebirth-et csinál: az érmék és a fejlesztések nullázódnak, minden kattintás pedig x2-t ér.

A szimulátor egy háromlépéses ciklus. A játékos újra és újra csinál valami egyszerűt, hogy valutát keressen, elkölti fejlesztésekre, amelyek gyorsabban hozzák, és amikor a fejlesztések drágák lesznek, rebirth-et csinál: odaadja az érméit és a fejlesztéseit egy bónuszért, amely örökre megmarad, és újra felfut, már gyorsabban. Más szimulátorokban kattintás helyett súlyt emelnek, ásnak vagy tárgyakat gyűjtenek, de alatta ugyanaz a ciklus van.

A három lépés ennek az útmutatónak a ciklusában
LépésMennyibe kerülMit adKi dönt
KattintásSemmibeClick Power × (Rebirths + 1) érmeA szerver, amely minden egy másodperces ablakban legfeljebb 15 kattintást számol be
Fejlesztés10 érme, utána minden szintért az előző ár 1,5-szereseMég egy Click Power szint, legfeljebb az 50-igA szerver, az árak saját példánya alapján
Rebirth1 000 érme, utána minden rebirth-ért az előző ár 3-szorosaAz érmék vissza 0-ra, a Click Power vissza 1-es szintre, plusz állandó +1 a szorzóhozA szerver

Minden szám a szerveren él. A játékos eszköze kirajzolja a gombokat és kér ("kattintottam", "fejlesztést szeretnék"), a szerver pedig eldönti, mennyit ér ez, és meg lehet-e csinálni. A feltört kattintós scriptek gyakran LocalScriptben adják hozzá az érméket, vagy hagyják, hogy a kliens küldje el, hány érmét kell hozzáadni.

Miből áll a szimulátor
ElemHol vanMit csinál
ModuleScript SimulatorConfigReplicatedStorageÁrak, korlátok és képletek a kattintás értékéhez, a fejlesztés árához és a rebirth árához. Mindkét oldal olvassa.
Script SimulatorServiceServerScriptServiceTárolja minden játékos számait, kezeli a kattintásokat, a fejlesztéseket és a rebirth-öket, és kitölti a leaderstatsot.
Folder SimulatorRemotesReplicatedStorage (a SimulatorService hozza létre)A Click RemoteEvent és a BuyUpgrade és Rebirth RemoteFunction.
LocalScript SimulatorClientStarterPlayerScriptsMegépíti a gombokat, elküldi a kattintásokat és a kéréseket, és megmutatja a szerver számait.
ModuleScript PlayerData (nem kötelező)ServerScriptServiceElmenti az előrehaladást a belépések között. A DataStore útmutatóból származik, és csak a 4. lépéshez kell.
Az Explorer játék közben. A SimulatorService a játék indulásakor létrehozza a SimulatorRemotes mappát és a három remote-ot, a PlayerData pedig csak akkor jelenik meg, amikor a 4. lépésben hozzáadod a mentést.
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

1. lépés: tedd ki az árakat és a képleteket egy modulba

Minden szám, amelyen esetleg állítani akarsz, egyetlen ModuleScriptbe kerül: mennyit ér egy kattintás, mennyibe kerül minden fejlesztés és rebirth, és a kattintási korlát. A szerver ez alapján dönt, a LocalScript pedig innen veszi az árakat a gombokhoz, így minden változtatás egyetlen javítás egyetlen helyen.

  1. Az Explorerben vidd az egeret a ReplicatedStorage fölé, nyomd meg a + gombot, és szúrj be egy ModuleScriptet.
  2. Nevezd át erre: SimulatorConfig (a nevekben számít a kis- és nagybetű), és cseréld le a tartalmát az alábbi kódra.
ModuleScript helye: ReplicatedStorage neve: SimulatorConfig
-- A fő ciklus összes száma és a képletek, amelyeket mindkét oldal használ. A kliens csak
-- megjeleníti az árakat ezek alapján; a szerver a saját példánya alapján dönt.

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- a 2-es szintű Click Power ára
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- minden szint 1,5-szer többe kerül az előzőnél
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- érmék az első rebirth-höz
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- minden rebirth 3-szor többe kerül az előzőnél
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- az ezen felüli kattintásokat egy másodpercen belül figyelmen kívül hagyjuk

-- Érmék egy kattintásért: a Click Power szint szorozva 1 + a rebirth-ök számával
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- A következő Click Power szint ára
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- A következő rebirth-höz szükséges érmék
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

A játékosok el tudják olvasni a ReplicatedStorage-ban lévő ModuleScriptet, így ezek az árak nyilvánosak. Ez rendben van: úgyis ott állnak a gombokon. A kliens és a szerver a modul saját példányát futtatja, ezért ha egy játékos a saját eszközén átírja a számokat, azzal a szerveren semmit sem változtat.

Mit adnak a képletek ezekkel a beállításokkal
Click Power szintA következő szint áraÉrme kattintásonként, rebirth nélkülÉrme kattintásonként, 1 rebirth
11012
21524
32236
43348
550510

A rebirth-ök ára 1 000 érme, aztán 3 000, aztán 9 000, mert a rebirthCost minden alkalommal 3-mal szorozza az árat. Egy rebirth után minden kattintás kétszer annyit ér, kettő után háromszor annyit, és így tovább.

Meddig tart egy rebirth ezekkel a számokkal

A képletek döntik el, meddig tart a ciklus, ezért érdemes kiszámolni a számokat, mielőtt a játékosok teszik meg. A táblázat feltételezi, hogy a játékos rebirth-et csinál, amint ki tudja fizetni, egyébként pedig megveszi a következő Click Power szintet, amikor ki tudja fizetni, és olcsóbb a rebirth-nél. Az idő egy új kezdéstől számít, ezért az utolsó oszlop a 3 rebirth-ig eltelt teljes idő.

Percek egy új kezdéstől az egyes rebirth-ökig másodpercenként 5 kattintással, REBIRTH_BASE_COST szerint. A SimulatorConfig képleteiből számolva, nem játékosokon mérve
REBIRTH_BASE_COST1. rebirth2. rebirth3. rebirth
1 000 (ez az útmutató)1,22,74,8
5 0004,310,118,3
10 0008,216,933,2
25 00016,740,174,5
50 00032,868,8137,8

Rebirth nélkül az 5-ös Click Power szint 34 kattintás után jön el, a 10-es 122 után, a 13-as pedig 285 után. Az alapértelmezett számokkal a játékos ezután abbahagyja a fejlesztést, mert a 14-es szint 1 297 érmébe kerül, többe, mint az 1 000 érmés rebirth, és az első rebirth összesen 362 kattintás után jön el. Másodpercenként 15 kattintásos szerverkorlátnál minden időt ossz el 3-mal. Ha bármelyik számot megváltoztatod a SimulatorConfigban, ezek az idők is vele változnak, ezért számold ki őket újra.

A növekedés beállítása

A két _GROWTH szám adja meg, milyen gyorsan nőnek az árak. 1,5-nél minden fejlesztés másfélszer többe kerül az előzőnél, minden szint viszont csak egy érmét ad hozzá kattintásonként (a rebirth szorzó előtt), így minden új szint egyre lassabban térül meg. Épp ez a lassulás teszi kifizetődővé a rebirth-et. Emeld a növekedést egy hosszabb felfutásért, csökkentsd egy gyorsabbért, és tartsd a REBIRTH_BASE_COST értékét elég magasan ahhoz, hogy a játékosok az első rebirth előtt vegyenek néhány fejlesztést.

Ha azt szeretnéd, hogy az első rebirth néhány perc múlva jöjjön, ne nagyjából egy perc múlva, emeld a REBIRTH_BASE_COST értékét 5 000-re vagy 10 000-re.

2. lépés: add hozzá a szerverscriptet

Ez a Script birtokol minden számot. Létrehozza a remote-okat, minden játékosnak ad egy leaderstats mappát Coins és Rebirths értékkel, és válaszol a három kérésre. Vidd az egeret a ServerScriptService fölé, szúrj be egy Scriptet, nevezd át erre: SimulatorService, és cseréld le a tartalmát erre a kódra:

Script helye: ServerScriptService neve: SimulatorService
-- Birtokol minden számot: a kattintások itt hoznak érmét, a fejlesztéseket és a rebirth-öket itt veszik meg,
-- a leaderstats pedig csak az eredményt mutatja.

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- false: minden belépéskor mindenki nulláról kezd. true: betöltés és mentés a PlayerData modullal
-- a DataStore útmutatóból (előbb add hozzá a PowerLevel = 1 és Rebirths = 0 értéket a DEFAULTS táblájához).
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 } = {} -- mikor kezdődött a játékos aktuális egy másodperces ablaka
local clickCount: { [Player]: number } = {} -- az ebben az ablakban beszámolt kattintások

-- A szerver számait oda másolja, ahol a játékosok látják őket: a leaderstatsba és egy attribútumba
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

-- Elindítja a játékost a kapott adatokkal (új számok vagy mentett tábla)
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

-- A kattintás nem hordoz számokat: hogy mennyit ér, azt a szerver számolja
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 -- autoclicker vagy egy script, amely ciklusban hívja a remote-ot
	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
	-- A rebirth az érméket és a fejlesztéseket egy állandó szorzóra cseréli
	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

-- Kezdő számok: újak, vagy a tábla, amelyet a PlayerData modul betölt és ment
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) -- ugyanaz a tábla, amelyet a PlayerData ment, így minden változás mentődik
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- mindenki, akinek az adatai a script indulása előtt betöltődtek
	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)

A Click Power PowerLevel attribútumként jut el a játékoshoz a Player objektumán, nem harmadik értékként a leaderstatsban, ezért a játékoslista csak a Coins és a Rebirths értéket mutatja. A szerver által beállított attribútumok replikálódnak a játékos eszközére; ha a játékos a saját eszközén változtat rajtuk, az ott is marad.

Kattintások és gyakorisági korlát

A Click remote nem ad át argumentumokat. A szerveren az OnServerEvent kezelő első paramétere mindig az a játékos, aki meghívta, ezért a szerver tudja, ki kattintott, veszi a Click Power szintjét és a Rebirths értékét, és hozzáadja a clickValue értéket a Coins értékéhez. A kérésben nincs semmi, amit egy csaló átírhatna.

A Roblox biztonsági útmutatója szerint soha ne támaszkodj csak a kliensoldali gyakorisági korlátra, és a valuta jóváírása ott szerepel azok között a műveletek között, amelyeket korlátozni kell. A szerver minden játékos kattintásait egy másodperces ablakokban számolja: az első kattintás megnyitja az ablakot, és amikor 15 kattintás be van számolva, a többit figyelmen kívül hagyja, amíg az ablak kezdete óta el nem telik egy másodperc. Egy script, amely ciklusban hívja a remote-ot, minden ablakban legfeljebb 15 beszámolt kattintást kap. Ha gyorsabb vagy lassabb kattintást akarsz engedni, változtasd meg a MAX_CLICKS_PER_SECOND értékét a SimulatorConfigban.

Fejlesztések és rebirth-ök

A BuyUpgrade és a Rebirth RemoteFunction, ezért a gomb megvárhatja a választ, és megjelenítheti. Minden kezelő a SimulatorConfig szerveroldali példányából veszi az árat, ellenőrzi a játékos Coins értékét, és csak utána változtat bármin. true vagy false értéket ad vissza és egy üzenetet, például "You need 5 more coins.", amelyet a LocalScript az állapotsorban mutat.

Az ár ellenőrzése és a változtatás között semmi sem vár és nem adja át a végrehajtást (yield), ezért ugyanannak a játékosnak két kérése nem mehet át mindkettő az ellenőrzésen, mielőtt az első elvenné az érméket. A rebirth a Coins értékét 0-ra, a Click Powert 1-es szintre állítja, és 1-et ad a Rebirths értékhez, a kattintási képlet pedig ebből Rebirths + 1 szorzót csinál.

A SAVE_PROGRESS kapcsoló

A SAVE_PROGRESS = false beállítással minden játékos minden belépéskor 0 érmével kezd, és amíg a játékot építed, épp ez kell. A 4. lépés bekapcsolja. Ekkor a script megvárja, amíg a PlayerData modul minden játékost betölt, és közvetlenül azzal a táblával dolgozik, amelyet a modul ment, így minden érme és minden rebirth extra kód nélkül mentődik.

3. lépés: építsd meg a gombokat

Ez a LocalScript kódból építi fel az egész képernyőt: egy érmeszámlálót fent, egy nagy Click gombot középen, Upgrade és Rebirth gombokat lent, és egy állapotsort a szerver válaszainak. Maga soha egyetlen számot sem változtat meg.

  1. Az Explorerben nyisd ki a StarterPlayer elemet, vidd az egeret a StarterPlayerScripts fölé, és szúrj be egy LocalScriptet SimulatorClient néven.
  2. Cseréld le a tartalmát az alábbi kódra, és nyomd meg a Play gombot.
LocalScript helye: StarterPlayerScripts neve: SimulatorClient
-- Megépíti a szimulátor gombjait, és megmutatja a szerver számait. Maga soha nem változtat rajtuk.

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))
-- A Click gomb négyzetes marad, a képernyőhöz igazodik, és legfeljebb 200 × 200-as,
-- hogy telefonon elférjen az érmeszámláló és az alsó gombok között
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()

-- A "+N", amely felugrik a gomb fölött. A szám csak becslés a látvány kedvéért;
-- hogy a kattintás valójában mennyit ér, azt a szerver dönti el.
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)

A gombok az Activated eseményt használják, amelyet a Roblox számítógépen bal egérkattintásra, telefonon érintésre, kontrolleren pedig UI-navigációs módban az A (vagy kereszt) gomb megnyomására vált ki.

Kontrolleren az A csak a kijelölt gombot nyomja meg. Ha a GuiService.AutoSelectGuiEnabled be van kapcsolva, a kontroller Select gombja kijelöli a képernyőn lévő gombjaidat; onnan a játékosok válthatnak köztük, és megnyomhatják az A-t. Ha azt szeretnéd, hogy egy kontrollergomb azonnal kattintson, kösd hozzá a ContextActionService segítségével, és hívd belőle ugyanazt a Click remote-ot.

Négy részlet a scriptben:

  • A Click gomb a képernyőhöz méreteződik. A mérete a képernyő egy hányada, az UIAspectRatioConstraint négyzetesen tartja, az UISizeConstraint pedig 200 × 200 pixelre korlátozza. Monitoron 200 pixel széles; telefonon összemegy, és elfér az érmeszámláló és az alsó gombok között. Ha elemeket mozgatsz, tartsd távol tőlük: a Rebirth gombnak nincs megerősítése, így egy véletlen érintés nullázhatja a játékos érméit és fejlesztéseit.
  • A felugró "+N" csak a látvány kedvéért van. A képlet kliensoldali példányát használja. Ha a szerver a gyakorisági korlát miatt figyelmen kívül hagy egy kattintást, a "+N" így is megjelenik, de az érmék nem változnak.
  • A short() olvashatóvá teszi a nagy számokat. Az 1 234 így jelenik meg: 1.2K, az 5 600 000 pedig így: 5.6M. A függvény lefelé kerekít, így a számláló soha nem mutat többet, mint amennyid van. A T-nél (billió) nagyobb számokhoz adj új bejegyzéseket a UNITS táblához.
  • A képernyő események alapján frissül. Figyeli a Coins és a Rebirths értéket és a PowerLevel attribútumot, így a gombokon lévő árak helyesek, bárhogy változnak is a számok.

A ScreenGui ResetOnSpawn értéke false, ezért megmarad, amikor a karakter újraéled. Ez itt fontos: a StarterPlayerScriptsben lévő LocalScript belépéskor egyszer másolódik a játékoshoz, így nem építené újra a képernyőt.

4. lépés: mentsd az előrehaladást a PlayerData modullal

Egyelőre minden nullázódik, amikor a játékos kilép. Egy második mentőscript helyett a szimulátor a DataStore útmutató PlayerData moduljához csatlakozik. Ez a modul már újrapróbálja a sikertelen kéréseket, 180 másodpercenként automatikusan ment, ment a játékos kilépésekor és a szerver leállásakor, és soha nem menti azt a játékost, akinek az adatai nem töltődtek be.

  1. Végezd el a DataStore útmutató 1. lépését, hogy hozzáadd a PlayerData ModuleScriptet a ServerScriptService-hez. Hogy a Studióban tesztelhesd a mentést, a játék tesztpéldányában kapcsold be a Studio hozzáférését az API-szolgáltatásokhoz, ahogy az útmutató első része elmagyarázza. A SimulatorService maga tölti be a modult a require hívással, így az útmutató Main scriptjére itt nincs szükség.
  2. A PlayerData modulban add hozzá a PowerLevel = 1, és a Rebirths = 0, sort a DEFAULTS táblához, a Coins = 0, mellé.
  3. Ugyanebben a modulban add hozzá a PowerLevel: number, és a Rebirths: number, sort a Data típushoz, hogy a szigorú típusellenőrzés tudjon az új mezőkről.
  4. A SimulatorService-ben cseréld le a local SAVE_PROGRESS = false sort erre: local SAVE_PROGRESS = true.

Azok a játékosok, akik még a mezők hozzáadása előtt mentettek, automatikusan megkapják őket: a PlayerData migrate függvénye kitölti a DEFAULTS összes olyan mezőjét, amely hiányzik a mentett táblából, így 1-es Click Power szinttel és 0 rebirth-del kezdenek, és megtartják a Coins értéküket. Ha kihagyod a 2. pontot, a SimulatorService figyelmeztetést ír ki a hozzáadandó mezőkkel, és nem indítja el a játékost.

Miért ír a szimulátor a PlayerData táblájába

Ha a mentés be van kapcsolva, a SimulatorService sehová sem másolja a számokat. A PlayerData.Get(player) azt az élő táblát adja vissza, amelyet a modul ment, a szimulátor pedig ugyanebben a táblában változtatja a Coins, a PowerLevel és a Rebirths értéket. Minden számnak egy példánya van, és egyetlen script ír az adattárba. Két script, amely ugyanazt a kulcsot menti, felülírja egymást, és az egyik a régi számokat mentheti el a másik számai fölé.

Ne készíts külön leaderstatsot is a Loaded kezelőben, ahogy a DataStore útmutató más játékokhoz tanácsolja: a SimulatorService már elkészíti a Coins és a Rebirths értéket a betöltött táblából. Ha a leaderstatsot már egy ranglista script készíti, töröld.

Miért ne ments minden kattintásnál

A Roblox szerverenként percenként 60 + 40 × játékosok írást enged egy hagyományos adattárba (a többi a DataStore útmutató korláttáblázatában van). Ha másodpercenként 15 kattintásnál minden kattintásra mentesz, az játékosonként percenként 900 írás, sokkal több annál a 100-nál, amelyet egy egyjátékos szerver kap. Ha az egész táblát 180 másodpercenként, a játékos kilépésekor és a szerver leállásakor mented, az játékosonként csak néhány írás, összeomláskor pedig legfeljebb az utolsó automatikus mentés óta elért előrehaladás vész el.

Ha a betöltés nem sikerült, a modul hagyja, hogy a játékos új számokkal játsszon, de soha nem menti őket, így egy rossz betöltés nem írhatja felül a valódi előrehaladást. Az útmutató elmagyarázza, hogyan kezeli ezt a modul.

Miért a szerver dönt el minden számot

Az exploiterek a saját eszközüket irányítják. A Roblox biztonsági útmutatója szerint bármit megváltoztathatnak a játék helyi példányában, és bármelyik RemoteEventet vagy RemoteFunctiont annyiszor hívhatják, ahányszor csak akarják, bármilyen argumentummal. Egy szimulátor gazdasága pontosan annyira védett, amennyire a szerverscriptje.

Mivel próbálkozhat egy exploiter, és mit csinál a SimulatorService
Az exploiter megpróbáljaHa a kliens dönteneMit csinál a SimulatorService
Ciklusban, a lehető leggyorsabban hívni a Click remote-otVégtelen érmeMinden egy másodperces ablakban legfeljebb 15 kattintást számol be, a többit figyelmen kívül hagyja.
Érmemennyiséget küldeni a kattintássalMaga választja ki a jutalmátMinden argumentumot figyelmen kívül hagy. A kattintás értéke a szerver számaiból jön.
Fejlesztést vagy rebirth-et venni a szükséges érmék nélkülIngyenes fejlesztésekÖsszeveti az árat a szerveren lévő Coins értékkel, és ezt válaszolja: "You need N more coins."
Átírni a Coins értéket a leaderstatsban a saját képernyőjénOlyan érméket költeni, amelyek nincsenek meg nekiSoha nem olvassa a leaderstatsot. Csak ír bele a saját táblájából.
Beállítani a PowerLevel attribútumot a saját PlayerénErősebb kattintásSoha nem olvassa ezt az attribútumot, a változás pedig a játékos eszközén marad.
Egyszerre kétszer hívni a Rebirth-etKét rebirth egy áráértMinden hívásnál újra ellenőrzi az árat, és az ellenőrzés és a változtatás között semmi sem adja át a végrehajtást.
Átírni az árakat a SimulatorConfig saját példányábanOlcsóbb fejlesztésekA modul saját példányát használja.

A szabály a szimulátor minden remote-jára érvényes: azt küldd, amit a játékos csinálni akar, ne azt, hogy mennyit ér. A RemoteEventről szóló útmutató részletesebben tárgyalja a remote-ok argumentumainak ellenőrzését.

Mit kerülj a lemásolt kattintós scriptekben

Gyakori fogások régi kattintós útmutatókból, és mit csinál helyettük ez az útmutató
FogásProblémaEz az útmutató
A LocalScript így ad hozzá érméket: leaderstats.Coins.Value += 1A változás egyetlen eszközön marad, a saját eszközét pedig az exploiter irányítjaAz érméket a szerver adja hozzá
clickEvent:FireServer(amount)A kliens maga választja ki a jutalmátA Click nem ad át argumentumokat
Nincs gyakorisági korlát a szerverenA Roblox dokumentációja szerint soha ne támaszkodj csak a kliensoldali korlátraMinden egy másodperces ablakban legfeljebb 15 kattintás
SetAsync minden kattintásnál vagy fejlesztésnélFelemészti a szerver írási korlátjátA PlayerData 180 másodpercenként, kilépéskor és leálláskor ment. Csak olyasmi után ments azonnal a PlayerData.SaveNow hívással, amit nem szabad elveszíteni, például Robuxos vásárlás után.
Egy második adattárscript csak a szimulátornakKét script, amely ugyanazt a kulcsot menti, felülírja egymástA PlayerData táblájába ír
while wait(1) do ciklusok passzív bevételhezA Roblox elavultnak jelöli a globális wait függvényt, a helyére a task.wait léptask.wait (lásd: Hogyan bővítsd)
MouseButton1Click a gombokonEgérkattintásokra van leírvaActivated, egérhez, érintéshez és kontrollerhez

5. lépés: teszteld

Az 1-8. pontokat a SimulatorService-ben SAVE_PROGRESS = false beállítással végezd el, hogy minden játékteszt új számokkal induljon. Ha a 4. lépésben már bekapcsoltad a mentést, egyelőre állítsd false-ra, a 9. ponthoz pedig állítsd vissza true-ra.

  1. Nyomd meg a Play gombot. A képernyő tetején 0 coins áll, a zöld gombon Upgrade: 10, a narancssárgán pedig Rebirth: 1.0K.
  2. Nyomd meg tízszer a lila Click! gombot. Minden kattintás egy arany +1-et mutat, a Coins pedig a játékoslistában 1-gyel nő.
  3. Nyomd meg az Upgrade gombot. Az érmék visszamennek 0-ra, az állapotsor zöldre vált ezzel a szöveggel: "Click Power is now level 2.", a gombon pedig most Upgrade: 15 áll. Mostantól minden kattintás 2 érmét ad.
  4. Kattintás nélkül nyomd meg a Rebirth gombot. Az állapotsor ezt írja: "You need 1000 more coins to rebirth.", és semmi sem változik.
  5. Ha 1 000 kattintás nélkül akarod tesztelni a rebirth-et, állítsd le a tesztet, a SimulatorService vége felé abban a sorban, amely az új játékosokat indítja, írd át a Coins = 0 részt erre: Coins = 1000, és nyomd meg a Play gombot. Nyomd meg a Rebirth gombot: a Coins 0 lesz, a Rebirths a játékoslistában 1 lesz, az állapotsor ezt írja: "Rebirth 1! Every click is now worth x2.", a gombon pedig most Rebirth: 3.0K áll. Minden kattintás most 2 érmét ad 1-es Click Power szinten. Utána állítsd vissza a sort 0-ra.
  6. Hogy lásd a gyakorisági korlátot, állítsd a MAX_CLICKS_PER_SECOND értékét a SimulatorConfigban 2-re, és kattints gyorsan. A "+N" feliratok továbbra is megjelennek, de a Coins másodpercenként legfeljebb 2 kattintás értékével nő. Állítsd vissza 15-re.
  7. Válassz ki egy telefont a Studio Device Simulatorában (ez Studio béta; a régi Device Emulator is megfelel), és nyomd meg a Play gombot. Ellenőrizd, hogy a Click gomb nem lóg rá sem az érmeszámlálóra, sem az Upgrade és Rebirth gombokra, és hogy az állapotsor az Upgrade megnyomásakor látható, és nem takarja el a gomb.
  8. Csatlakoztass egy kontrollert, vagy nyisd meg a Studio Controller Emulator eszközét (Controller az Emulation lapon) játékteszt közben, nyomd meg a Select gombot, és ellenőrizd, hogy mindhárom gombot el lehet érni és meg lehet nyomni az A-val.
  9. Bekapcsolt mentéssel (4. lépés) és ismét SAVE_PROGRESS = true beállítással keress néhány érmét, nyomd meg a Stop gombot, aztán újra a Play gombot. A Coins, a Click Power szinted és a Rebirths értéked visszajön.

Készíts edzőtermes vagy bányás szimulátort

Sok szimulátor a gombot egy világbeli cselekvésre cseréli: súlyzót emelni, csákánnyal csapni, karddal suhintani a levegőben. Alatta ugyanaz a kattintás van. Egy Tool ugyanazt a Click remote-ot hívhatja, így a SimulatorService, az árai és a gyakorisági korlátja változatlanok maradnak.

  1. Az Explorerben vidd az egeret a StarterPack fölé, szúrj be egy Toolt, és nevezd el így: Dumbbell. Szúrj bele egy Partot Handle néven, formázd súlyzóvá, és vedd ki a pipát az Anchored elől, ahogy a kardról szóló útmutató Toolos lépéseiben.
  2. Szúrj a Toolba egy LocalScriptet LiftClient néven, és illeszd be az alábbi kódot.
  3. Nyomd meg a Play gombot, vedd fel a súlyzót, és kattints. Az érmék minden emelésnél a Click Powereddel nőnek, pontosan úgy, mint a gombbal.
LocalScript helye: a StarterPackben lévő Dumbbell Toolban neve: LiftClient
-- LocalScript a Dumbbell Toolban, LiftClient néven.
-- Minden emelés egy kattintás: ugyanazt a Click remote-ot hívja, mint a gomb, a szerver pedig
-- eldönti, mennyit ér, és hány emelést számol be.

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 -- idő az emelések között ezen az eszközön; a szervernek saját korlátja van
local LIFT_ANIMATION_ID = "" -- nem kötelező: "rbxassetid://", utána az animációd id-je

local player = Players.LocalPlayer
local lastLift = 0
local liftTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil

-- Karakterenként egyszer betöltjük az emelés animációját az Animatoron keresztül, amelyet a Roblox a Humanoidba tesz
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() -- argumentumok nélkül: a jutalmat a szerver számolja
end)

Az emelés animációját készítsd el az Animation Editorban Action prioritással, publikáld, és illeszd be az ID-ját a LIFT_ANIMATION_ID értékbe. A kardról szóló útmutató animációs lépései ugyanígy működnek.

  • Igazítsd a szerverkorlátot a cselekvéshez. A LIFT_SECONDS csak a becsületes játékosokat fékezi: egy csaló a saját kódjából hívhatja a Click remote-ot. Ha az emelés az egyetlen kereseti mód, csökkentsd a MAX_CLICKS_PER_SECOND értékét a SimulatorConfigban a valódi tempóra, például 2-re, ha 0,5 másodpercenként van egy emelés, hogy egy script ne kereshessen többet egy játékosnál. Utána számold újra a tempótáblázatot: minden ideje másodpercenként 5 kattintásra van számolva.
  • Hagyd meg vagy rejtsd el a gombot. A Click gomb a Tool mellett is tovább működik. Az elrejtéséhez add hozzá a clickButton.Visible = false sort közvetlenül a SimulatorClient azon sora után, amely létrehozza a clickButton gombot.
  • Kereset csak a megfelelő helyen. Ha csak az edzőteremben vagy a bányában akarsz fizetni, a kattintás beszámolása előtt a szerveren ellenőrizd, hol van a karakter, például a terület egyik partjától mért távolság alapján. Egy ellenőrzés a LiftClientben senkit sem állítana meg.

Mi a következő lépés: a szimulátor építési sorrendje

A szimulátor rendszerek halmaza erre a ciklusra építve. Ebben a sorrendben építsd őket, hogy mindegyiknek legyen mit szoroznia, és mindegyik után tarts játéktesztet. Ez az általunk javasolt sorrend, minden lépéshez egy útmutatóval.

Egy Roblox szimulátor építési sorrendje, a fő ciklustól kifelé
SorrendRendszerÚtmutatóMiért épp most
1Kereset, fejlesztés, rebirthEz az útmutatóMinden más ezt a ciklust szorozza, ezért előbb állítsd be a számait a tempótáblázat alapján.
2MentésDataStore útmutató, aztán a 4. lépésAz előrehaladás, amely újracsatlakozáskor nullázódik, megöli a szimulátort. Mindennél előbb add hozzá, amit a játékosok elveszíthetnek.
3Tojások és petek mint szorzókTojások kinyitása és petek, amelyek követik a játékostEgy második cél az érmék mellett: valami, amit gyűjteni lehet, és ami minden kattintást értékesebbé tesz.
4Rebirth-ökkel nyíló területekHogyan bővítsdHová lehet menni a rebirth után, jobb jutalmakkal, amelyeket a szerver ellenőriz.
5RanglistákRanglista útmutatóEgy globális top 10 rebirth-ök szerint értelmet ad a hosszú felfutásnak.
6Napi jutalmak és kódokNapi jutalmak és kódokOkok arra, hogy holnap és minden frissítés után visszajöjjenek.
7Game passokGame pass útmutató2x érme, automatikus kattintás vagy extra pethely, szerveroldali ellenőrzéssel. Akkor árusítsd őket, amikor az ingyenes ciklus már érdekes.

A képernyőkhöz az ingyenes Roblox UI kitek szimulátor stílusú képernyőket is tartalmaznak, a működtetésükhöz szükséges scriptekkel együtt.

Hogyan készíts szimulátort scriptek írása nélkül

Egy szimulátorhoz mindenképp kellenek scriptek: valakinek hozzá kell adnia az érméket, ellenőriznie kell az árakat, és mentenie kell. Neked magadnak nem kötelező megírnod őket:

  • Szimulátorcsomag a Creator Store-ból. Publikálás előtt olvasd el a scriptjeit, és ellenőrizd, hogy az érmék csak egy szerveroldali Scriptben változnak, nem LocalScriptben.
  • Szimulátorgeneráló plugin. Ugyanez az ellenőrzés mindenre, amit létrehoz.
  • AI-ügynök a Studióban, például a RoCode, amely ugyanezt a három scriptet meg tudja építeni a nálad nyitott place-ben.
  • Build a Roblox mobilalkalmazásban. A Roblox dokumentációja szerint leírás alapján egyszerűbb 2D és 2.5D játékokat készít, például kattintós játékokat, és régiónként fokozatosan jelenik meg.

Bármit választasz, futtasd le az eredményen az 5. lépés ellenőrzéseit és a Miért a szerver dönt el minden számot rész exploitellenőrzéseit.

Hogyan bővítsd: petek, területek, automatikus kattintás és ranglisták

Petek mint szorzók

Gyakori változat: minden pet egy szorzó. A játékos petjeinek id-listáját tárold a mentett táblájában, a szerver pedig szorozza meg a clickValue értéket minden felszerelt pet bónuszával. A tojásokat a szerveren nyisd ki: a kliens kéri a tojás kinyitását, a szerver ellenőrzi és levonja az árat, aztán súlyozott véletlen húzással kiválasztja a petet. Soha ne hagyd, hogy a kliens dobjon a tojásért, vagy megmondja, melyik pet jött ki. Az inventoryról szóló útmutató megmutatja, hogyan tárold, mentsd és jelenítsd meg a játékos tárgyait, és a petek ugyanígy működnek. A tojásnyitási útmutató a szerveren építi meg a húzást, a petekről szóló útmutató pedig a gazdájuk mellett lebegteti a peteket.

Rebirth-ökkel nyíló területek

Egy terület a pálya egy része jobb jutalmakkal egy akadály mögött. A jutalmat zárd le, ne csak az ajtót: mindennek, ami a területen belül fizet, ellenőriznie kell a játékos Rebirths értékét a szerver táblájában, mielőtt fizet. Egy ajtó, amelyet egy LocalScript a jogosult játékosoknak kinyit, a látványhoz megfelel, de az exploiterek a saját eszközükön módosíthatják a partokat és mozgathatják a karakterüket.

Automatikus kattintás game passként

Egy game passként árult autoclickernek a szerveren kell futnia. Tedd át a Click kezelő törzsét egy függvénybe, például addClick(player), kösd hozzá a remote-ot, a pass tulajdonosainál pedig egy szervercikluson belül hívd task.wait(0.5) hívással, ne az elavult wait függvénnyel. Így az automatikus kattintások ugyanabba a másodpercenkénti korlátba számítanak bele, mint a normál kattintások. A birtoklást a szerveren ellenőrizd a MarketplaceService:UserOwnsGamePassAsync hívással, ahogy a game pass útmutató teszi a saját bónuszainál. A 2x érme pass ugyanígy működik: a szerveren szorozd meg a clickValue értéket a tulajdonosoknál. Mielőtt árat szabsz, az ingyenes Robux-adó kalkulátor megmutatja, mennyit hoz neked egy eladás a Roblox részesedése után, a DevEx kalkulátor pedig azt, mennyit érnek ezek a Robuxok amerikai dollárban.

Globális top 10 rebirth-ök szerint

A leaderstats csak az egy szerveren lévő játékosokat hasonlítja össze. Ha minden játékos Rebirths értékét rangsorolni akarod, írd őket egy rendezett adattárba (ordered data store), és olvasd vissza a legfelső bejegyzéseket, ahogy a ranglista útmutató 4. lépésében. A rendezett adattárak kevesebb írást engednek, mint a hagyományosak, szerverenként percenként 30 + 5 × játékosok, ezért a játékos kilépésekor és időzítővel írj.

Nagyon nagy számok

A Luau számai double típusúak, nagyjából 15 értékes jegyet tárolnak. Az IntValue egész számokat tárol körülbelül 9,2 trillióig, de a Roblox figyelmeztet, hogy a 2^53-nál (körülbelül 9 billiárd) nagyobb értékek veszítenek a pontosságukból a scriptekben. Ezekkel a beállításokkal a rebirth ára a 29. rebirth-nél lépi át ezt a határt. Ha a játékod tovább megy, állítsd át a leaderstats értékeket NumberValue típusra (cseréld le az IntValue típust mindkét scriptben), amely sokkal nagyobb számokat tárol ugyanazzal a nagyjából 15 jegyes pontossággal, és adj hozzá utótagokat a short() függvényhez.

Min múlik egy szimulátor játék

A szimulátor a számok játéka. A fenti kattintás, fejlesztés és rebirth az egész ciklus; hogy a játékosok maradnak-e, azon múlik, hogyan nőnek ezek a számok. Néhány percenként a játékosnak meg kell engedhetnie magának valamit, ami felgyorsítja a következő néhány percet, és minden menetnek egy olyan cél közelében kell véget érnie, amelyért vissza akar jönni.

  • Növekedés, amely sokáig kitart. A fejlesztések ára gyorsabban nő, mint a bevétel, ezért minden fokozat egy kicsit tovább tart. A rebirth egy állandó szorzóért nullázza az érméket, a régi terület gyorssá válik, a felfutás pedig újnak érződik.
  • Mit lehet gyűjteni. Megnyitandó területek, tojásokból kikelő petek, amelyek megszorozzák a keresetet, és fejleszthető eszközök célok listáját adják a játékosoknak egyetlen számon túl.
  • Nagy számok, amelyek olvashatók maradnak. 1.5M-et mutass, ne 1500000-t, és úgy tárold a számokat, hogy a szerver akkor is össze tudja hasonlítani őket, amikor nagyok lesznek.

Pénzszerzés, amely illik egy szimulátorhoz

A gyakori passok megszorozzák az érméket, extra pethelyet adnak, egyszerre több tojást nyitnak, vagy bekapcsolják az automatikus kattintást. Game passként árusítsd őket, és a szerveren ellenőrizd. Az érmecsomagok developer productok. Ha a tojásokat vagy bármit, aminek véletlenszerű az eredménye, Robuxért vagy Robuxért vett valutáért lehet megvenni, a Roblox megköveteli, hogy az esélyeket a vásárlás előtt mutasd meg: olvasd el a paid random items oldalt (angolul), mielőtt megépíted a boltot.

Mi hozza vissza a játékosokat

Mentett előrehaladás, egy új terület vagy petkészlet a frissítésekben, napi jutalmak, kódok, amelyeket a frissítésekkel együtt jelentenek be, és egy ranglista rebirth-ök szerint. Más műfajok, mindegyik saját ciklussal, rendszerekkel és építési tervvel: játékműfajok Robloxban.

Gyakori hibák és megoldásaik

Nyisd meg az Output ablakot (Window menü, majd Output), mielőtt megnyomod a Play gombot. A legtöbb probléma ott figyelmeztetést vagy hibát ír ki a script nevével és a sorral.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("SimulatorRemotes")'

A LocalScript azokra a remote-okra vár, amelyeket a SimulatorService indításkor hoz létre. Ellenőrizd, hogy a SimulatorService Script legyen, ne LocalScript, hogy a ServerScriptService-ben legyen, és hogy nincs-e tőle hiba az Outputban. Ugyanez a figyelmeztetés a SimulatorConfig esetén azt jelenti, hogy a modul nincs a ReplicatedStorage-ban, vagy másképp van elnevezve.

A gombok egyáltalán nem jelennek meg

A LocalScript a leaderstatsodra vár, mielőtt felépíti a képernyőt. Ha az Outputban Infinite yield possible áll a leaderstats mellett, a SimulatorService még nem indított el téged. SAVE_PROGRESS = true beállítással a PlayerData modulra vár, ezért ellenőrizd, hogy a PlayerData a ServerScriptService-ben van, és hiba nélkül töltődik be.

Az Outputban ez áll: "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"

A mentés be van kapcsolva, de a PlayerData modulban még nincsenek meg az új mezők. Add hozzá őket a DEFAULTS táblájához, ahogy a 4. lépésben, és nyomd meg újra a Play gombot.

A "+1" feliratok felugranak, de az érmék nem nőnek

A szerver nem számolja be a kattintásokat. Vagy hiba van a SimulatorService-ben (keresd tőle a piros szöveget az Outputban), vagy a kattintások gyorsabban érkeznek, mint amit a MAX_CLICKS_PER_SECOND enged. Ha a játékosok normál játék közben elérik a korlátot, emeld meg a SimulatorConfigban.

Az állapotsor ezt írja: "No answer from the server. Try again."

A BuyUpgrade vagy a Rebirth hívás összeomlott ahelyett, hogy választ adott volna. A szokásos ok egy hiba a SimulatorService-ben a kérés feldolgozása közben, ezért keresd tőle a piros hibát az Outputban: ott a sor is szerepel.

A képernyőn lévő érmeszámláló és a játékoslista különböző számot mutat

Egy másik script is készít leaderstats mappát, így minden játékosnak kettő van, és a LocalScript a másikat olvashatja. Töröld a felesleges scriptet: a SimulatorService maga készíti el a Coins és a Rebirths értéket.

Az érmék minden újracsatlakozáskor nullázódnak

A mentés ki van kapcsolva. Végezd el a 4. lépést. Ha be van kapcsolva, de a Studióban az érmék így is nullázódnak, ellenőrizd, hogy a tesztpéldányban be van-e kapcsolva a Studio hozzáférése az API-szolgáltatásokhoz, ahogy a DataStore útmutató elmagyarázza.

Elkészítés RoCode-dal

Ha nincs kedved ezt kézzel beilleszteni, a RoCode megépítheti a nálad nyitott place-ben. Ez egy független AI-ügynök kódoláshoz, nem a Robloxtól: a webes chatjében leírod a rendszert, a Roblox Studio pluginja pedig létrehozza a scripteket az Explorerben, így nem kell kódot másolnod a chatablakból.

Te írod

Készíts egy kattintós szimulátort: egy nagy Click gombot, amely a Click Power szintem és a (rebirth-ök + 1) szorzatának megfelelő érmét ad, egy Upgrade gombot, amely 10 érmébe kerül, és szintenként 1,5-szer drágul, és egy 1 000 érmés Rebirth gombot, amely nullázza az érméket és a fejlesztéseket. A számokat tartsd a szerveren, és korlátozd a kattintásokat másodpercenként 15-re. Már van PlayerData modulom.

A RoCode elvégzi
  • Először elolvashatja a PlayerData modulodat és bármelyik leaderstats scriptet a Search Scripts és a Read Script eszközzel, hogy a meglévő adataidhoz adja hozzá a mezőket, ahelyett hogy egy második mentőscriptet írna
  • Elkészítheti a képernyő vázát a Build UI HUD-elrendezésével (3.9-es vagy újabb pluginnal, szimulátor stílusban), vagy LocalScriptben építheti meg a gombokat, a ModuleScriptet, a szerveroldali Scriptet és a LocalScriptet pedig a Create Script eszközzel írja
  • Az a feladata, hogy minden megírt script fordítását ellenőrizze a Check Scripttel, amely futtatás nélkül lefordítja a Studióban
  • Minden módosításcsomag előtt és után visszavonási pontot tesz, így a Ctrl+Z egyszerre egy csomagot von vissza

A RoCode nem tud game passokat és developer productokat létrehozni, sem petmesheket és ikonokat feltölteni: ezt a Creator Hubban és a Studióban kell megcsinálni. 3.9.11-es vagy újabb pluginnal a RoCode játéktesztet indíthat a Studióban, és irányíthat egy tesztkaraktert, hogy ellenőrizze, minden működik-e, 3.9.15-ös vagy újabb pluginnal pedig a tesztkarakter képernyőgombokat is megnyomhat, például megnyomja a Click gombot, és ellenőrzi, hogy a Coins nőtt-e. Maga dönti el, mikor indít játéktesztet, építésenként legfeljebb 2-t, plusz 1-et a saját javítása ellenőrzésére, és csak azt ellenőrzi, amit kiválasztott, ezért a ciklust ellenőrizd te is. Egy teljes szimulátor több prompt, egyszerre egy rendszer: hogyan építs a RoCode-dal promptonként egy rendszert. Hogyan csatlakozik a RoCode a Studióhoz.

Gyakori kérdések

Hogyan készítsek szimulátort Robloxban scriptek nélkül?

Egy működő szimulátorhoz scriptek kellenek: valakinek hozzá kell adnia az érméket, ellenőriznie kell az árakat, és mentenie kell az előrehaladást. Beillesztheted az útmutató három scriptjét úgy, ahogy vannak, és csak a SimulatorConfig számait változtatod, vagy rábízhatod egy Creator Store csomagra, egy pluginra vagy egy AI-ügynökre, és ellenőrzöd, hogy az érméket a szerver dönti el. Lehetőségek.

Hogyan működik a rebirth rendszer?

A rebirth az érméidet és a fejlesztéseidet egy állandó bónuszra cseréli. Ebben az útmutatóban az első rebirth 1 000 érmébe kerül; a Coins értéket 0-ra, a Click Powert 1-es szintre állítja, és 1-et ad a Rebirths értékhez, onnantól pedig minden kattintás Rebirths + 1-gyel szorzódik. Minden rebirth háromszor annyiba kerül, mint az előző.

Hogyan készítsek erő- vagy edzőtermes szimulátort?

Adj a játékosoknak egy Toolt, például egy súlyzót, amelynek a LocalScriptje a Tool.Activated eseményre ugyanazt a Click remote-ot hívja. A szerver pontosan úgy számolja a jutalmat, mint egy gombkattintásnál. Csökkentsd a szerver kattintási korlátját az emelések tempójára, hogy egy script ne kereshessen többet egy játékosnál. A script a súlyzós változat részben van.

Milyen rendszerek kellenek egy szimulátorba?

Először a kereset, a fejlesztések és a rebirth-ök ciklusa, aztán a mentés, aztán petek vagy más gyűjthető dolgok, amelyek megszorozzák a keresetet, rebirth-ökkel nyíló területek, ranglisták, napi jutalmak és kódok, és a legvégén game passok. Az építési sorrendben mindegyikhez van útmutató.

Meddig tartson egy rebirth?

Elég sokáig ahhoz, hogy a játékosok előbb vegyenek néhány fejlesztést, és elég rövid ideig ahhoz, hogy az első menetben eljussanak egyig. Az útmutató számaival az első rebirth nagyjából 1,2 perc múlva jön el másodpercenként 5 kattintással; ha a REBIRTH_BASE_COST értékét 10 000-re emeled, körülbelül 8 perc lesz. További beállítások a tempótáblázatban.

Hogyan védekezzek az autoclickerek ellen?

A szerver játékosonként minden egy másodperces ablakban legfeljebb 15 kattintást számol be, a többit figyelmen kívül hagyja. E korlát alatt egy script ugyanúgy néz ki, mint egy gyors játékos, így a gazdaságot éppen a korlát védi. Az automatikus kattintást game passként is árulhatod, amely a szerveren fut.

Miért nullázódnak az érmék újracsatlakozáskor?

Egyelőre semmi sem menti őket. Add hozzá a PlayerData modult a DataStore útmutatóból, add hozzá a PowerLevel és a Rebirths mezőt a DEFAULTS táblájához, és állítsd be a SAVE_PROGRESS = true értéket a SimulatorService-ben, ahogy a 4. lépésben.

Hogyan adjak peteket a szimulátorhoz?

Tedd minden petet szorzóvá, amelyet a szerver a kattintásokra alkalmaz. A tojásokat a szerveren nyisd ki súlyozott véletlen választással, a játékos petjeinek id-jeit a többi adatával együtt mentsd, és egy inventory GUI-ban mutasd meg őket, ahogy az inventoryról szóló útmutatóban.

Mi a jobb: partra vagy gombra kattintani?

Mindkettő megfelel. A képernyőgomb telefonon kényelmes, a ClickDetectorral ellátott part pedig olyan játékhoz illik, ahol minden a világban történik. A Roblox dokumentációja szerint a szerver egyáltalán nem ellenőrzi a ClickDetector eseményeit, ezért ezeknek a kattintásoknak a gyakoriságát is ugyanígy korlátozd a szerveren.

Források és további olvasnivaló

Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.