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
Hogyan épül fel a szimulátor fő ciklusa
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.
| Lépés | Mennyibe kerül | Mit ad | Ki dönt |
|---|---|---|---|
| Kattintás | Semmibe | Click Power × (Rebirths + 1) érme | A szerver, amely minden egy másodperces ablakban legfeljebb 15 kattintást számol be |
| Fejlesztés | 10 érme, utána minden szintért az előző ár 1,5-szerese | Még egy Click Power szint, legfeljebb az 50-ig | A szerver, az árak saját példánya alapján |
| Rebirth | 1 000 érme, utána minden rebirth-ért az előző ár 3-szorosa | Az érmék vissza 0-ra, a Click Power vissza 1-es szintre, plusz állandó +1 a szorzóhoz | A 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.
| Elem | Hol van | Mit csinál |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | Á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 SimulatorService | ServerScriptService | Tárolja minden játékos számait, kezeli a kattintásokat, a fejlesztéseket és a rebirth-öket, és kitölti a leaderstatsot. |
Folder SimulatorRemotes | ReplicatedStorage (a SimulatorService hozza létre) | A Click RemoteEvent és a BuyUpgrade és Rebirth RemoteFunction. |
LocalScript SimulatorClient | StarterPlayerScripts | Megé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ő) | ServerScriptService | Elmenti 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. |
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.
- Az Explorerben vidd az egeret a ReplicatedStorage fölé, nyomd meg a + gombot, és szúrj be egy ModuleScriptet.
- 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.
-- 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.
| Click Power szint | A következő szint ára | Érme kattintásonként, rebirth nélkül | Érme kattintásonként, 1 rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
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ő.
REBIRTH_BASE_COST | 1. rebirth | 2. rebirth | 3. rebirth |
|---|---|---|---|
| 1 000 (ez az útmutató) | 1,2 | 2,7 | 4,8 |
| 5 000 | 4,3 | 10,1 | 18,3 |
| 10 000 | 8,2 | 16,9 | 33,2 |
| 25 000 | 16,7 | 40,1 | 74,5 |
| 50 000 | 32,8 | 68,8 | 137,8 |
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:
-- 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.
- Az Explorerben nyisd ki a StarterPlayer elemet, vidd az egeret a StarterPlayerScripts fölé, és szúrj be egy LocalScriptet
SimulatorClientnéven. - Cseréld le a tartalmát az alábbi kódra, és nyomd meg a Play gombot.
-- 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
UIAspectRatioConstraintnégyzetesen tartja, azUISizeConstraintpedig 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 aUNITStá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.
- Végezd el a DataStore útmutató 1. lépését, hogy hozzáadd a
PlayerDataModuleScriptet 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óMainscriptjére itt nincs szükség. - A PlayerData modulban add hozzá a
PowerLevel = 1,és aRebirths = 0,sort aDEFAULTStáblához, aCoins = 0,mellé. - Ugyanebben a modulban add hozzá a
PowerLevel: number,és aRebirths: number,sort aDatatípushoz, hogy a szigorú típusellenőrzés tudjon az új mezőkről. - A SimulatorService-ben cseréld le a
local SAVE_PROGRESS = falsesort 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.
| Az exploiter megpróbálja | Ha a kliens döntene | Mit csinál a SimulatorService |
|---|---|---|
| Ciklusban, a lehető leggyorsabban hívni a Click remote-ot | Végtelen érme | Minden 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ással | Maga választja ki a jutalmát | Minden 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ül | Ingyenes 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én | Olyan érméket költeni, amelyek nincsenek meg neki | Soha 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én | Erősebb kattintás | Soha 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-et | Két rebirth egy áráért | Minden 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ában | Olcsóbb fejlesztések | A 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
| Fogás | Probléma | Ez az útmutató |
|---|---|---|
A LocalScript így ad hozzá érméket: leaderstats.Coins.Value += 1 | A változás egyetlen eszközön marad, a saját eszközét pedig az exploiter irányítja | Az érméket a szerver adja hozzá |
clickEvent:FireServer(amount) | A kliens maga választja ki a jutalmát | A Click nem ad át argumentumokat |
| Nincs gyakorisági korlát a szerveren | A Roblox dokumentációja szerint soha ne támaszkodj csak a kliensoldali korlátra | Minden egy másodperces ablakban legfeljebb 15 kattintás |
SetAsync minden kattintásnál vagy fejlesztésnél | Felemészti a szerver írási korlátját | A 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átornak | Két script, amely ugyanazt a kulcsot menti, felülírja egymást | A PlayerData táblájába ír |
while wait(1) do ciklusok passzív bevételhez | A Roblox elavultnak jelöli a globális wait függvényt, a helyére a task.wait lép | task.wait (lásd: Hogyan bővítsd) |
MouseButton1Click a gombokon | Egérkattintásokra van leírva | Activated, 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.
- 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.
- 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ő.
- 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.
- 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.
- 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 = 0ré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. - 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. - 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.
- 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.
- Bekapcsolt mentéssel (4. lépés) és ismét
SAVE_PROGRESS = truebeá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.
- Az Explorerben vidd az egeret a StarterPack fölé, szúrj be egy Toolt, és nevezd el így:
Dumbbell. Szúrj bele egy PartotHandlené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. - Szúrj a Toolba egy LocalScriptet
LiftClientnéven, és illeszd be az alábbi kódot. - 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 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_SECONDScsak 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 aMAX_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 = falsesort közvetlenül a SimulatorClient azon sora után, amely létrehozza aclickButtongombot. - 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.
| Sorrend | Rendszer | Útmutató | Miért épp most |
|---|---|---|---|
| 1 | Kereset, fejlesztés, rebirth | Ez 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. |
| 2 | Mentés | DataStore útmutató, aztán a 4. lépés | Az 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. |
| 3 | Tojások és petek mint szorzók | Tojások kinyitása és petek, amelyek követik a játékost | Egy második cél az érmék mellett: valami, amit gyűjteni lehet, és ami minden kattintást értékesebbé tesz. |
| 4 | Rebirth-ökkel nyíló területek | Hogyan bővítsd | Hová lehet menni a rebirth után, jobb jutalmakkal, amelyeket a szerver ellenőriz. |
| 5 | Ranglisták | Ranglista útmutató | Egy globális top 10 rebirth-ök szerint értelmet ad a hosszú felfutásnak. |
| 6 | Napi jutalmak és kódok | Napi jutalmak és kódok | Okok arra, hogy holnap és minden frissítés után visszajöjjenek. |
| 7 | Game passok | Game 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.
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.
- 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ó
- Roblox Creator Docs: Securing the client-server boundary (angolul). gyakorisági korlát, játékon belüli bolt példája és ClickDetector események
- Roblox Creator Docs: Security and cheat mitigation tactics (angolul). mit irányít az exploiter a saját eszközén
- Roblox Creator Docs: Remote events and callbacks (angolul). FireServer, a játékos paraméter, InvokeServer és OnServerInvoke
- Roblox Creator Docs: Leaderboards (angolul). leaderstats és rendezett adattárak
- Roblox Creator Docs: Data store error codes and limits (angolul). szerverenkénti írási korlátok hagyományos és rendezett adattárakhoz
- Roblox Engine API: GuiButton (angolul). Activated számítógépen, telefonon és konzolon
- Roblox Engine API: GuiService (angolul). AutoSelectGuiEnabled és GUI-objektumok kijelölése kontrollerrel
- Roblox Engine API: IntValue (angolul). 64 bites tartomány és pontosságvesztés 2^53 felett
- Roblox Creator Docs: Size modifiers and constraints (angolul). UIAspectRatioConstraint és UISizeConstraint
- Roblox Creator Docs: Studio testing modes (angolul). Device Simulator és Controller Emulator
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.