Útmutató · Scriptelési alapok

Hogyan írj scripteket a Roblox Studióban: útmutató kezdőknek

A scriptelés, vagyis a programozás a Roblox Studióban azt jelenti, hogy Luau nyelven, a Lua nyelv Roblox-féle változatán írsz kódot a place-hez hozzáadott scriptekben. Ez az útmutató egy üres Baseplate-ből indul: megnyitod az Output ablakot, megírod az első scriptedet, kódból módosítasz egy partot, reagálsz egy játékosra, aki rálépett egy platformra, és kipróbálsz egy LocalScriptet, közben pedig megismered a változókat, a függvényeket, a feltételeket, a ciklusokat és az eseményeket.

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

Röviden

Ha scriptet szeretnél írni a Roblox Studióban, az Explorerben vidd a kurzort a ServerScriptService fölé, kattints a + gombra, és illessz be egy Scriptet. A Studio megnyitja a Script Editorban. Írj Luau kódot, például print("Hello"), nyomd meg a Play gombot (F5), és olvasd el az eredményt az Output ablakban (Window menü vagy Script fül). A Script a szerveren fut, és mindenki számára mindent megváltoztat; a StarterPlayerScripts-ben lévő LocalScript egyetlen játékos eszközén fut.

  • Először négy ötletet tanulj meg: változók (local coins = 3), függvények (local function name() ... end), if feltételek és események (part.Touched:Connect(...)). Az útmutató négy scriptje ezekből épül fel, plusz ciklusokból és táblákból.
  • A task.wait()-et használd, ne a wait()-et. A Roblox referenciája a globális wait()-et elavultként jelöli, amelyet a task.wait() váltott fel.
  • Az Output ablak megjelenítési beállításaiban kapcsold be a Show Context opciót, hogy minden sor mutassa, a Serverről vagy a Clientről érkezett-e.
Ezen az oldalon
  1. Mielőtt elkezded
  2. 1. Első script
  3. 2. Part módosítása
  4. 3. Események
  5. 4. Első LocalScript
  6. 5. Teszt
  7. Hová tedd a scripteket
  8. Hibák olvasása
  9. Régi oktatóanyagok
  10. Gyakorlás
  11. Mi jön ezután
  12. Common errors
  13. RoCode-dal
  14. Gyakori kérdések
  15. Források és további olvasnivaló

Mielőtt elkezded: Studio, Baseplate és az Output ablak

IllusztrációNégy script egy játéktesztben: a ColourChanger part másodpercenként színt vált, a Padra lépés 2 másodpercre minden játékosnak sárgává teszi, és kiírja a neved az Outputba, az E pedig csak ezen a képernyőn teszi átlátszóbbá a Padot.

Roblox Studio és egy Roblox fiók kell, semmi más: se kódszerkesztő, se plugin. Az útmutató minden scriptjét a Studio saját Script Editorában írod meg.

  1. Telepítsd a Roblox Studiót, a Roblox ingyenes alkalmazását Windowsra és Macre, és jelentkezz be a Roblox fiókoddal.
  2. Nyisd meg a Studiót. A kezdőoldalon sablonok vannak: válaszd a Baseplate sablont. Kapsz egy 4x4-es rácsmintás padlót és egy SpawnLocationt, azt a helyet, ahol az avatarod megjelenik játék közben.
  3. Ha az Explorer és a Properties ablak nem látszik, nyisd meg őket a Window menüből vagy a Home fülről. Az Explorer a place összes objektumát felsorolja; a Properties a kijelölt objektum beállításait mutatja.
  4. Nyisd meg az Output ablakot a Window menüből vagy a Script fülről. Itt jelennek meg a scriptjeid üzenetei és hibái.
  5. Az Output ablak megjelenítési beállításaiban kapcsold be a Show Context opciót, amely minden üzenetet Client vagy Server címkével lát el, és a Show Source opciót, amely megmutatja, melyik scriptből és hányadik sorból jött.
A négy script, amelyet megírsz
ScriptTípusHol vanMit tanít
FirstScriptScriptServerScriptServiceVáltozók, függvény, if feltétel, ciklusok és tábla
ColourChangerScriptEgy Parton belül a Workspace-benTulajdonságok módosítása, script.Parent és ciklus várakozással
TouchPadScriptEgy Pad nevű Parton belülEsemények, a partot megérintő játékos megkeresése és debounce
MyFirstLocalScriptLocalScriptStarterPlayerScripts, a StarterPlayeren belülKód egyetlen játékos eszközén, billentyűleütések, és mi marad ezen az eszközön
Az Explorer a végén (csak ennek az útmutatónak az objektumai)
Workspace
  Baseplate Part
  SpawnLocation SpawnLocation
  Part Part new
    ColourChanger Script new
  Pad Part new
    TouchPad Script new
ServerScriptService
  FirstScript Script new
StarterPlayer
  StarterPlayerScripts
    MyFirstLocalScript LocalScript new

1. lépés: írd meg az első scriptedet

  1. Az Explorerben vidd a kurzort a ServerScriptService fölé, kattints a + gombra, és válaszd a Script lehetőséget (billentyűparancs: Ctrl+I, Macen ⌘I). A Studio létrehozza a scriptet, és megnyitja a Script Editorban.
  2. Kattints jobb gombbal az új scriptre, válaszd a Rename lehetőséget, és nevezd el FirstScript néven. A név nem változtat azon, amit a script csinál, de megmondja, melyik script mit írt ki.
  3. Az új scriptek egyetlen sorral kezdődnek: print("Hello world!"). Töröld, és illeszd be az alábbi kódot.
  4. Nyomd meg a Play gombot (F5) úgy, hogy a tőle balra lévő listában a Test van kiválasztva. A Studio elindít egy játéktesztet, és az avatart a SpawnLocationre teszi.
  5. Olvasd el a sorokat az Outputban, majd nyomd meg a Stop gombot (Shift+F5). A Stop minden objektumot a Play megnyomása előtti állapotba is visszaállít, ezért minden, amit játék közben elmozdítottál vagy átfestettél, visszaáll.
Script helye: ServerScriptService neve: FirstScript
-- Script a ServerScriptService-ben, FirstScript néven.
-- Az első Luau kódod: változók, függvény, if feltétel, ciklus és tábla.
-- Nyomd meg a Play gombot (F5), és olvasd el az eredményt az Output ablakban.

-- A változó egy név, amely egy értéket tárol
local gameName = "Coin Run"
local coinsToWin = 3

-- A függvény egy elnevezett kódblokk, amelyet akárhányszor lefuttathatsz.
-- A name és a goal a paraméterei; a return értéket ad vissza annak, aki meghívta.
local function describe(name: string, goal: number): string
	return `{name}: collect {goal} coins to win`
end

print(describe(gameName, coinsToWin)) --> Coin Run: collect 3 coins to win

-- Az if feltétel csak akkor futtatja a kódot, ha a feltétel igaz
if coinsToWin > 5 then
	print("That is a long game")
elseif coinsToWin > 1 then
	print("That is a short game")
else
	print("One coin and you win")
end

-- A for ciklus megadott számú alkalommal ismétli a kódot
for count = 1, coinsToWin do
	print("Coin number", count)
end

-- A tábla értékek listáját tárolja; ez a ciklus sorban végigmegy rajtuk
local colours = { "Red", "Green", "Blue" }
for position, colour in colours do
	print(position, colour) --> 1 Red, aztán 2 Green, aztán 3 Blue
end

Egy sorban minden, ami a -- után jön, megjegyzés: a Luau kihagyja, így jegyzeteket hagyhatsz magadnak. A --> megjegyzések azt mutatják, mit ír ki az adott sor.

Az Outputnak ezt a nyolc sort kell mutatnia, a Studio saját üzeneteivel keverve. Ha a print több értéket kap, szóközt tesz közéjük. Bekapcsolt Show Context és Show Source mellett minden sor Server és FirstScript címkét is kap a sor számával.

Output (várt)
Coin Run: collect 3 coins to win
That is a short game
Coin number 1
Coin number 2
Coin number 3
1 Red
2 Green
3 Blue

Párosítsd össze minden sort azzal a kóddal, amely kiírta. Később ugyanezt fogod csinálni a hibaüzenetekkel, úgyhogy hasznos szokás.

A FirstScript csak tiszta Luau kódot használ Roblox objektumok nélkül, ezért az ingyenes, böngészőben futó Luau homokozóban is működik. Változtass meg ott egy értéket, és futtasd újra, hogy lásd, mi változik.

Mit csinál a FirstScript egyes része
KódÖtletMit jelent
local gameName = "Coin Run"VáltozóEgy név, amely egy értéket tárol. A local azt jelenti, hogy csak ez a script vagy az a blokk használhatja, amelyben áll. Az idézőjelek közötti szöveg egy string; a 3 egy szám. A nevekben számít a kis- és nagybetű, ezért a coinsToWin és a CoinsToWin két különböző változó.
local function describe(name: string, goal: number): stringFüggvényEgy elnevezett kódblokk, amelyet akárhányszor lefuttathatsz. A name és a goal a paraméterei: értékek, amelyeket minden hívásnál átadsz. A : string és a : number opcionális típusannotációk. A Luau arra használja őket, hogy a Script Editorban figyelmeztessen a hibákra; nélkülük a kód ugyanúgy működik.
returnVisszatérési értékÉrtéket ad vissza a függvényt meghívó kódnak. A print(describe(gameName, coinsToWin)) azt írja ki, amit a describe visszaad.
`{name}: collect {goal} coins to win`StringinterpolációA backtickek közötti szöveg értékeket is tartalmazhat: a Luau a {name} és a {goal} helyére az aktuális értéküket teszi.
if, elseif, else, endIf feltételA Luau fentről lefelé ellenőrzi a feltételeket, és csak az első igazat futtatja. A coinsToWin értéke 3, ami nem nagyobb 5-nél, de nagyobb 1-nél, ezért csak a „That is a short game” íródik ki.
for count = 1, coinsToWin doNumerikus for ciklusA belsejében lévő kódot egyszer lefuttatja minden számra 1-től coinsToWin-ig, ahol a count értéke 1, aztán 2, aztán 3.
{ "Red", "Green", "Blue" } és for position, colour in colours doTábla és ciklusA tábla listaként, a Luau ezt tömbnek hívja. A pozíciók 1-től kezdődnek, nem 0-tól. A ciklus végigmegy minden elemen, és megadja a pozícióját és az értékét.

Minden blokkot, amely a function, if, for vagy while szóval nyílik, az end szó zár le. Egyetlen kihagyott end az egész script futását megakadályozza; a hibák olvasása rész megmutatja, milyen üzenetet kapsz ilyenkor.

2. lépés: módosíts egy partot scriptből

A scriptek akkor válnak hasznossá, amikor megváltoztatnak valamit a világban. A Properties ablakban látható beállítások, például egy part Color, Transparency vagy Anchored értéke, tulajdonságok, és egy script is beállíthatja őket.

  1. A Home fülön kattints a Part gombra. A Studio egy blokkot ad a Workspace-hez. A neve nem számít.
  2. Az Explorerben vidd a kurzort az új part fölé, kattints a + gombra, és illessz be egy Scriptet. Nevezd át ColourChanger névre, és cseréld le a tartalmát az alábbi kódra.
  3. Nyomd meg a Play gombot. A part piros, aztán kék, aztán zöld lesz, másodpercenként váltva, majd elölről kezdi.
Script helye: bármelyik part a Workspace-ben neve: ColourChanger
-- Script egy Parton belül a Workspace-ben, ColourChanger néven.
-- A scriptek ugyanazokat a tulajdonságokat módosítják, amelyek a Properties ablakban látszanak.
-- Ez másodpercenként új színt ad a partjának, minden játékos számára.

local part = script.Parent :: BasePart -- a part, amelyen belül ez a script van

local colours = {
	Color3.fromRGB(255, 85, 85), -- piros
	Color3.fromRGB(85, 170, 255), -- kék
	Color3.fromRGB(85, 255, 127), -- zöld
}

part.Anchored = true -- a rögzített part ott marad, ahová tetted

local index = 1
while true do
	part.Color = colours[index]
	index = index % #colours + 1 -- 1, 2, 3, aztán újra 1
	task.wait(1) -- egy másodperc szünet (a régi wait() elavult)
end
  • A script.Parent az az objektum, amelyen belül a script van, itt a part. Húzd át a scriptet egy másik partba, és azt fogja módosítani.
  • A :: BasePart egy típuskényszerítés. Megmondja a Script Editornak, hogy a szülő egy part, hogy ellenőrizni tudja a használt tulajdonságokat. A Luau a típusokat csak figyelmeztetésekhez és tippekhez használja, ezért a kényszerítés nem változtat azon, amit a sor csinál.
  • A part.Color és a part.Anchored ugyanazok a tulajdonságok, mint a Properties ablakban, ugyanazzal a névvel. A Roblox amerikai helyesírást használ, ezért a tulajdonság neve Color, pedig a script neve ColourChanger.
  • Az Anchored = true a helyén tartja a partot: a Roblox referenciája szerint a rögzített partot soha nem mozdítja el a gravitáció, az ütközés vagy más fizika.
  • A colours[index] a lista egy elemét olvassa ki. A #colours a lista hossza, 3, a % pedig az osztás maradékát adja, ezért az index % #colours + 1 így számol: 1, 2, 3, 1, 2, 3.
  • A while true do a végtelenségig ismétlődik, ezért olyan fontos a belsejében lévő task.wait(1). A Roblox dokumentációja szerint egy végtelen ciklusba mindig tegyél késleltetést, például task.wait()-et: nélküle a játék lefagy, a Studio pedig összeomlik.

A ColourChanger egy Script, ezért a szerveren fut, és minden játékos ugyanazt a színt látja egyszerre. A 4. lépés egy másik scriptfajtát mutat be.

3. lépés: reagálj egy játékosra egy eseménnyel

A játékkód nagy része arra vár, hogy történjen valami: belépett egy játékos, megérintettek egy partot, megnyomtak egy gombot. A Roblox ezeket eseményeknek hívja. Ha kódot szeretnél futtatni, amikor egy esemény elsül, egy függvényt kötsz hozzá.

  1. Illessz be még egy Partot, és nevezd át pontosan Pad névre, nagy P-vel. Hagyd közvetlenül a Workspace-ben, ne mappában vagy modellben, mert a 4. lépés LocalScriptje ott keresi.
  2. Csinálj belőle egy lapos platformot, amelyre rá lehet állni, például állítsd a Size értékét 6, 1, 6-ra a Properties ablakban. Tedd a padlóra a SpawnLocation mellé, és kapcsold be az Anchored opciót, hogy ne mozduljon.
  3. Vidd a kurzort a Pad fölé, kattints a + gombra, illessz be egy Scriptet, nevezd át TouchPad névre, és illeszd be az alábbi kódot.
  4. Nyomd meg a Play gombot, és állj rá a platformra. 2 másodpercre sárga lesz, az Output pedig kiírja a neved.
Script helye: Workspace.Pad neve: TouchPad
-- Script egy Pad nevű Parton belül a Workspace-ben, a script neve TouchPad.
-- Események: amikor egy játékos rálép a platformra, az sárgán világít, az Output pedig kiírja, ki volt az.
-- A debounce megakadályozza, hogy a kód másodpercenként sokszor lefusson, amíg a játékos rajta áll.

local Players = game:GetService("Players")

local pad = script.Parent :: BasePart
local COOLDOWN_SECONDS = 2

local normalColour = pad.Color
local busy = false

local function onTouched(otherPart: BasePart)
	if busy then
		return -- még tart a cooldown az előző érintés után
	end
	-- A karakter az a Model, amelyben a platformot megérintő testrész (vagy kalap) van
	local character = otherPart:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player then
		return -- egy szabad part vagy egy NPC érintette meg, nem egy játékos
	end

	busy = true
	print(`{player.Name} stepped on the pad`)
	pad.Color = Color3.fromRGB(255, 220, 0)
	task.wait(COOLDOWN_SECONDS)
	pad.Color = normalColour
	busy = false
end

pad.Touched:Connect(onTouched)
Hogyan jut el a TouchPad az érintéstől a játékosig
KódMit csinál
pad.Touched:Connect(onTouched)Egy függvényt köt a platform Touched eseményéhez, ezért a Roblox minden alkalommal lefuttatja az onTouched függvényt, amikor valami megérinti a platformot, és átadja a megérintő partot.
otherPartA part, amely megérintette a platformot: egy lábfej, egy láb, egy kalap fogantyúja vagy egy tool a játékos kezében. Soha nem maga a játékos, ezért a következő két sor kideríti, kié.
otherPart:FindFirstAncestorOfClass("Model")Ettől a parttól felfelé halad az első olyan ősig, amelynek osztálya pontosan Model, vagyis a karakterig. Mivel az osztálynévnek pontosan egyeznie kell, kihagyja a kalapot (Accessory osztály) és a kézben tartott toolt (Tool osztály).
Players:GetPlayerFromCharacter(character)Visszaadja azt a Playert, akié a karakter, vagy nil-t, ha senkié, például egy NPC-é. Az előtte álló character and kihagyja a hívást, ha nem talált modellt, és a player nil marad.
if not player then return endItt megáll mindennél, ami nem játékos. A return idő előtt kilép a függvényből.

Miért kell a platformnak debounce

A Roblox debounce-ról szóló oldala figyelmeztet, hogy a Touched többször is elsül egymás után, amíg a partok érintkeznek, egy sétáló karakternek pedig több testrésze van. Ellenőrzés nélkül egyetlen lépés a platformra sok sort írhatna ki, és újra meg újra elindíthatná a sárga világítást.

A busy változó maga a debounce. Az első érintés true-ra állítja, és minden érintés a következő 2 másodpercben eljut az if busy then return end sorig, és megáll. A task.wait(COOLDOWN_SECONDS) után a platform visszakapja a színét, a busy pedig újra false lesz. A COOLDOWN_SECONDS nagybetűvel van írva, mert ez egy beállítás, amely játék közben nem változik: a Roblox így javasolja elnevezni a konstansokat.

Ennek a platformnak egy közös debounce-a van mindenkinek, ezért egy második játékos, aki ezalatt a 2 másodperc alatt lép rá, figyelmen kívül marad. Egy világító platformnál ez rendben van. Egy jutalmat adó platformnak játékosonként kell tartania a cooldownt, mint az érmés platformnak a ranglista útmutatóban.

4. lépés: az első LocalScript, és miben más

Egy futó játék egy szerverből és játékosonként egy kliensből áll. Eddig minden Script volt, amely a szerveren fut, ezért a változtatásai minden játékoshoz eljutnak. A LocalScript egyetlen játékos eszközén fut. A billentyűleütéseket, a kamerát és a képernyőn lévő menüket ott kezelik, mert csak ez az eszköz tud róluk.

  1. Az Explorerben nyisd ki a StarterPlayer elemet, vidd a kurzort a StarterPlayerScripts fölé, kattints a + gombra, és illessz be egy LocalScriptet. Nevezd át MyFirstLocalScript névre, és illeszd be az alábbi kódot.
  2. Nyomd meg a Play gombot. Az Output a Hello, szót és a neved mutatja Client címkével.
  3. Kattints a játékablakba, és nyomd meg az E gombot. A platform átlátszóbb lesz. Nyomd meg újra az E-t, hogy visszaállítsd.
  4. Amíg a játékteszt fut, kattints a Studio tesztelési vezérlői között a Client/Server kapcsolóra, hogy átválts a játék szerveroldali másolatára. Ott a platform nem átlátszó: a szerver semmit sem tudott meg a változásról.
LocalScript helye: StarterPlayerScripts neve: MyFirstLocalScript
-- LocalScript a StarterPlayer > StarterPlayerScripts helyen, MyFirstLocalScript néven.
-- A LocalScript egyetlen játékos eszközén fut. Nyomd meg az E-t: a Pad csak a te
-- képernyődön lesz átlátszóbb, mert a part innen végzett módosítása nem jut el se a szerverhez, se másokhoz.

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
print(`Hello, {player.Name}`) -- Client címkével jelenik meg az Outputban

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- a billentyű másra ment, például a chatbe gépelésre
	end
	if input.KeyCode == Enum.KeyCode.E then
		local pad = workspace:FindFirstChild("Pad")
		if pad and pad:IsA("BasePart") then
			pad.Transparency = if pad.Transparency == 0 then 0.6 else 0
		end
	end
end)
  • A Players.LocalPlayer az a játékos, akinek az eszközén a script fut. A Roblox csak a LocalScriptek és az általuk betöltött ModuleScriptek számára határozza meg, ezért szerveroldali kód nem használhatja.
  • A UserInputService.InputBegan akkor sül el, amikor a játékos elkezd egy billentyűleütést, kattintást vagy érintést. A gameProcessed akkor true, ha a motor már felhasználta ezt a bevitelt, például egy gombra kattintást vagy egy billentyűt a chatsorban, ezért a script figyelmen kívül hagyja.
  • A workspace:FindFirstChild("Pad") a Pad nevű leszármazottat adja vissza, vagy nil-t, ha nincs ilyen. A pad:IsA("BasePart") ellenőrzi, hogy tényleg part-e, mielőtt a script megváltoztatná a Transparency értékét.
  • Az if pad.Transparency == 0 then 0.6 else 0 egy if-kifejezés: két érték közül választ egyet. A 0-s Transparency teljesen láthatót jelent, az 1 láthatatlant.
  • A Shiftes futás script jó második LocalScript: egy billentyűt figyel, és a karakter WalkSpeed értékét módosítja.
Script, LocalScript és ModuleScript
TípusHol futHová jutnak el a változtatásokMire valóÁltalában itt van
ScriptA szerverenMinden játékoshozJátékszabályok: érmék, sebzés, ajtók, körök, mentésServerScriptService, vagy egy parton belül, amíg tanulsz
LocalScriptEgyetlen játékos eszközénCsak erre az eszközre, kivéve a saját karakter mozgásátBevitel, kamera, képernyős menük, effektek egy játékosnakStarterPlayerScripts vagy StarterGui
ModuleScriptAzon az oldalon, amely meghívja rá a require()-tUgyanoda, ahová a betöltő scriptéTöbb script által közösen használt kódReplicatedStorage mindkét oldalnak, ServerScriptService csak a szervernek

Mit tud megváltoztatni egy csaló

Számolj azzal, hogy a csaló mindent irányít a saját eszközén. Futtathatja a saját LocalScriptjeit, és módosíthatja a tieidet, így átlátszóvá teheti a platformot vagy bármi mást a saját képernyőjén. Itt ez ártalmatlan: az átlátszóság csak a látványt érinti, és az ő eszközén marad. Pontosan ezért dönt minden fontos dologról egy szerveroldali Script.

Egy szerveroldali Script sem biztonságos automatikusan. A TouchPad a szerveren fut, de minden játékos eszköze a saját karakterének fizikáját irányítja, és a Roblox biztonsági dokumentációja azok között, amiket a kliens az általa irányított partokkal megtehet, megemlíti a Touched elsülési pillanatának befolyásolását vagy teljes letiltását. Egy világító platformnál ez nem számít. Egy fizető platformnál azt is ellenőrizd, amit a szerver maga követ, mint az obby útmutató szabálya, hogy a checkpointok csak sorrendben számítanak.

5. lépés: teszteld együtt mind a négy scriptet

  1. Töröld az Output tartalmát a Ctrl+K-val (Macen ⌘K), és nyomd meg a Play gombot (F5). Az Output a FirstScript nyolc sorát mutatja Server címkével, és a Hello sorodat Client címkével. A ColourChanger part másodpercenként színt vált.
  2. Állj rá a platformra. 2 másodpercre sárga lesz, az Output pedig egyszer kiírja a neved és a „stepped on the pad” szöveget. Járkálj rajta: új sor legfeljebb 2 másodpercenként jelenik meg, nem minden Touched elsüléskor.
  3. Nyomd meg az E-t. A platform félig átlátszó lesz (Transparency 0,6). Nyomd meg újra az E-t, és nem átlátszó.
  4. Nyomd meg a Stop gombot. A tesztelési listában válaszd a Server & Clients lehetőséget, állíts be 2 klienst, és nyomd meg a Play gombot (vagy az F7-et). A Studio megnyit egy szerverablakot és két kliensablakot. Az egyik kliensben nyomd meg az E-t: a platform ott átlátszóbb lesz, a másik kliens és a szerver viszont nem átlátszónak mutatja. Ha végeztél, nyomd meg az End Session gombot.
  5. Ronts el valamit szándékosan. Nevezd át a Padot Pad2-re, és indítsd el a játékot. A platformra lépés továbbra is sárgává teszi, mert a TouchPad a script.Parent segítségével találja meg a partját, nem név alapján. Az E megnyomása most semmit sem csinál, és hiba sincs: a FindFirstChild("Pad") nil-t adott vissza, az if pad and ... ellenőrzés pedig csendben kihagyta a többit. Írd be a print(pad) sort a FindFirstChild utáni sorba, indítsd el, és nyomd meg az E-t: az Output nil-t mutat. Egy ilyen print a leggyorsabb módja annak, hogy megértsd, miért nem csinál semmit egy script. Állítsd le a játékot, töröld a print sort, és add vissza a partnak a Pad nevet.

Hová tedd a scripteket

Attól, hogy hol van egy script, függ, hogy egyáltalán elindul-e, és a Studio nem figyelmeztet, ha soha nem fog elindulni. A következő scriptjeidhez:

Hová tedd az egyes scriptfajtákat
TárolóMit tegyél beleMiért
ServerScriptServiceA játékszabályok többségét tartalmazó scripteket: jutalmak, körök, mentésA szerveren futnak, és a ServerScriptService tartalmából semmi sem jut el a játékosokhoz.
Egy parton belül a Workspace-benEgyetlen parthoz tartozó Scriptet, mint a ColourChanger és a TouchPadAmíg tanulsz, rendben van: a part a script.Parent. Valódi projektekhez a Roblox azt javasolja, hogy inkább címkézd fel a partokat (lásd lent).
StarterPlayerScripts, a StarterPlayeren belülA legtöbb LocalScriptet: bevitel, kamera, effektek egy játékosnakMinden játékos saját másolatot kap belépéskor.
StarterGuiScreenGui-kon belüli LocalScripteket, amelyek a képernyős menüt irányítjákMinden játékos saját másolatot kap a felületből.
ReplicatedStorageModuleScripteket, amelyeket a szerveroldali és a kliensoldali kód is betöltMindkét oldal látja. Egy alapbeállítású LocalScript vagy Script itt soha nem indul el.

A Roblox scriptek elhelyezéséről szóló oldala azt javasolja, hogy egyáltalán ne tegyél scripteket közvetlenül a Workspace partjaiba: címkézd fel a partokat, és egyetlen ModuleScriptből kezeld őket a CollectionService segítségével. A parton belüli script ettől még a legegyszerűbb kezdés, és egy-két objektumnál, amíg tanulsz, ez rendben van. Az ajtó útmutató a címkés mintát mutatja be, egyetlen scripttel az összes ajtóhoz, a kliensről és szerverről szóló útmutató pedig teljes táblázatot tartalmaz arról, melyik tároló melyik scripteket futtatja.

Ha valami elromlott: olvasd az Outputot

A hibák pirossal jelennek meg az Outputban. Mindegyik azzal kezdődik, hol történt: a script teljes nevével és a sor számával, aztán megmondja, mi a baj. Kattints a hibára, és a Studio megnyitja a scriptet ennél a sornál. Ha például kitörlöd az if not player ellenőrzést a TouchPadből, és egy szabad part esik a platformra, az Output ezt mutatja:

Output (példa)
Workspace.Pad.TouchPad:22: attempt to index nil with 'Name'

A kód megírásának hibái, például egy kihagyott end, már a Play megnyomása előtt látszanak: a Script Editor pirossal aláhúzza őket, a Script Analysis ablak (az Analysis gomb a Script fülön) pedig felsorolja őket. Egy ilyen hibát tartalmazó script egyáltalán nem indul el, még a hiba fölötti sorok sem.

Három hiba, amelyet érdemes felismerni
ÜzenetMit jelentHogyan javítsd
Colour is not a valid member of Part "Workspace.Part"Ennek az objektumnak nincs semmije ezzel a pontos névvel. Itt a tulajdonság neve Color.Vesd össze az írásmódot és a nagybetűket a Properties vagy az Explorer ablakkal. Bővebben erről a hibáról.
attempt to index nil with 'Name'A kód kiolvasott valamit, itt a .Name értéket, egy nil értékből. A fenti példában a player nil volt, mert egy szabad part érintette meg a platformot.Derítsd ki, miért nil az érték, és használat előtt ellenőrizd egy if-fel. Bővebben erről a hibáról.
Expected 'end' (to close 'then' at line 2), got <eof>A 2. sorban lévő if-nek nincs párja, egy end. Függvénynél az üzenet to close 'function' szöveget ír, az <eof> pedig a fájl végét jelenti.Add hozzá a hiányzó end-et a zárójelben lévő sor alapján, ne az utolsó sor alapján. Néha az üzenet a „did you forget to close ... at line N?” kérdéssel végződik. Ez a Luau tippje a behúzások alapján, és rossz blokkra is mutathat, ezért előbb a zárójelben lévő sort ellenőrizd. Bővebben a szintaktikai hibákról.

Ha a script semmit sem csinál, és az Output is üres, a script általában olyan helyen van, ahol soha nem indul el, vagy olyan eseményre vár, amely nem sül el. A hibákról szóló útmutatóban van egy ellenőrzőlista a néma scriptekhez, és bővebben szó esik az Output olvasásáról.

Mit csinálnak másképp a régi scriptelős oktatóanyagok

Ha videókból és fórumbejegyzésekből is tanulsz, régi mintákkal fogsz találkozni. Íme a fontosak, mindegyiknél azzal, miért probléma.

Minták a régi oktatóanyagokból, és mit csinál helyettük ez az útmutató
OktatóanyagProblémaEz az útmutató
A wait(1) segítségével tart szünetetA Roblox referenciája a globális wait()-et elavultként jelöli, és azt írja, hogy a task.wait() váltotta fel.task.wait(1)
Az otherPart.Parent segítségével találja meg a karaktert, mint a Roblox lávás leckéjébenAmikor egy kalap vagy egy kézben tartott tool érinti meg a partot, az otherPart.Parent egy Accessory vagy Tool, nem a karakter, ezért a Humanoid nem található meg, és az érintés elvész.FindFirstAncestorOfClass("Model"), aztán GetPlayerFromCharacter
A Touched eseményt debounce nélkül használjaA Touched egy lépésre többször is elsül egymás után, ezért a kód újra és újra lefut.Egy busy jelző és egy cooldown
A LocalScriptet egy partba teszi a Workspace-benOtt a LocalScript soha nem indul el. Csak egyetlen játékoshoz tartozó helyekről fut.LocalScript a StarterPlayerScripts-ben (miért)
part.Touched:connect(...) vagy table.getn(list) formát írA Roblox elnevezési útmutatója szerint a camelCase API-k többnyire elavultak, a referencia pedig csak a Connect-et sorolja fel. A table.getn elavult a #list javára.:Connect(...) és #list
LocalScriptben módosítja az érméket vagy okoz sebzéstA változás annak a játékosnak az eszközén marad, ezért senki más nem látja, és a szerver nem veszi figyelembe.Játékszabályok egy szerveroldali Scriptben

Gyakorlás: három módosítás, amelyet érdemes kipróbálni

A kód módosítása többet tanít, mint az olvasása. Próbáld ki ezeket a saját place-edben egyenként, és mindegyik után nyomd meg a Play gombot.

  • A platform adjon egy pontot. Add hozzá a Leaderstats scriptet a ranglista útmutató 1. lépéséből. Ezután a TouchPadben a busy = true után keresd meg a játékos leaderstats mappáját, és adj 1-et a Coins értékhez. Tipp: player:FindFirstChild("leaderstats"), aztán leaderstats:FindFirstChild("Coins"), aztán coins.Value += 1. A ranglista útmutató érmés platformja ennek kész változata, játékosonkénti cooldownnal.
  • A ColourChanger az átlátszóságot is váltsa. Érd el, hogy a ColourChanger másodpercenként a part Transparency értékét is módosítsa. Tipp: adj hozzá egy második táblát 0 és 1 közötti számokkal, például { 0, 0.3, 0.6 }, és ebből állítsd be a part.Transparency értékét a part.Color utáni sorban, ugyanazzal az index-szel.
  • Írasd ki a platform színét. A MyFirstLocalScript írja ki a platform Color értékét az E megnyomásakor. Tipp: print(pad.Color) az if pad and pad:IsA("BasePart") blokkon belül. Nyomd meg az E-t, amíg a platform sárga: a kliens a szerver által beállított színt látja, mert a szerveren végzett változtatások minden klienshez eljutnak.

Mit tanulj ezután

Most már használtad azokat az építőelemeket, amelyekből a legtöbb játékscript felépül. Jó sorrend innen:

  1. LocalScript vs Script vs ModuleScript: hol fut az egyes scripttípus, és mit módosíthat, mélyebben, mint a 4. lépés.
  2. RemoteEvents: hogyan kéri meg egy LocalScript a szervert, hogy csináljon valamit, és hogyan ellenőrzi a szerver a kérést.
  3. Ranglista: az első statisztikáid, amelyeket a szerveren hozol létre és módosítasz.
  4. Az első játékod: egy rövid pálya lávával, érmékkel és célplatformmal, két szerverscripttel, utána közzététel.
  5. Ezután válassz egy rendszert: bolt GUI, körrendszer, checkpointok obbyban, betöltőképernyő vagy animáció billentyűnyomásra. Ha valami elromlik, a script hibákról szóló útmutató segít elolvasni az üzenetet. A checkpointos útmutató egyelőre angolul érhető el.

A Roblox saját Coding fundamentals oktatóanyagai (angolul) jól kiegészítik ezt az útmutatót: hat sorozat a változóktól és függvényektől a feltételeken, ciklusokon, tömbökön és szótárakon át a kód ModuleScriptekbe szervezéséig, kis Studio-projektekkel.

Gyakori hibák és megoldásaik

Az első scriptekkel kapcsolatos problémák többsége egy nem egyező név, egy rossz helyen lévő script vagy egy várakozás nélküli ciklus. Tesztelés közben tartsd nyitva az Outputot.

A Studio lefagy vagy nem reagál, amikor megnyomom a Play gombot

A while true do ciklusban nincs várakozás, ezért semmi más nem tud lefutni. A Roblox dokumentációja szerint egy késleltetés nélküli végtelen ciklus, amelyben nincs például task.wait(), lefagyasztja a játékot, és összeomlasztja a Studiót. Tegyél task.wait()-et minden végtelen ciklusba, ahogy a ColourChangerben.

Semmi sem történik, amikor ráállok a platformra

Ellenőrizd, hogy a TouchPad Script-e, nem LocalScript, közvetlenül a Pad parton belül van-e, nincs-e kikapcsolva, és hogy a platform CanTouch tulajdonsága be van-e pipálva. Ezután írd be a print("touched", otherPart.Name) sort az onTouched első soraként. Ha ez nem íródik ki, az esemény nem sül el; ha kiíródik, a probléma lejjebb van.

Az E megnyomása semmit sem csinál

A MyFirstLocalScriptnek LocalScriptnek kell lennie a StarterPlayerScripts-en belül: a Workspace-ben vagy a ServerScriptService-ben lévő LocalScript soha nem indul el. A part neve pontosan Pad legyen, és közvetlenül a Workspace-ben legyen. Előbb kattints a játékablakba, és győződj meg róla, hogy nem a chatbe gépelsz, mert a script figyelmen kívül hagyja azokat a billentyűket, amelyeket a játék már felhasznált.

A part az én képernyőmön megváltozik, de a többi játékosnál nem

A változtatást egy LocalScript végezte, ezért a te eszközödön maradt. Csináld egy szerveroldali Scriptben, vagy a LocalScript kérje meg a szervert egy RemoteEventtel.

A ColourChanger egy parton belül működik, de a ServerScriptService-ben elromlik

A script.Parent-et használja a partjaként. A ServerScriptService-ben a szülő maga a ServerScriptService, amelynek nincs Anchored vagy Color tulajdonsága, ezért az Output egy „not a valid member” hibát mutat. Tartsd egy parton belül, vagy adj nevet a partnak, és név alapján keresd meg, például local part = workspace:WaitForChild("ColourPart") :: BasePart.

Az Output egyáltalán semmit sem mutat

Ellenőrizd, hogy az Output ablak nyitva van-e (Window menü vagy Script fül), és nincs-e beállítva szűrő: az Outputot üzenettípus, Client vagy Server, illetve szöveg szerint is lehet szűrni. Ha nyitva van, és mégis üres, a script valószínűleg el sem indult. Lásd az ellenőrzőlistát a semmit sem csináló scriptekhez.

Ha elakadtál: RoCode

Ha elakadtál egy scripttel a place-edben, a RoCode veled együtt végigmehet rajta. A RoCode egy független AI-ügynök a Roblox Studióhoz, nem a Robloxtól: a webes chatben írsz, a Studio pluginja pedig létrehozza és szerkeszti a scripteket az Explorerben.

Amíg tanulsz, az Ask mód hasznos: a scripteket te írod, a RoCode pedig elolvassa, ami már megvan, és válaszol a kérdéseidre.

Te írod

Magyarázd el soronként, mit csinál a Pad parton belüli TouchPad script, és miért használ debounce-ot.

A RoCode elvégzi
  • Ask módban csak olvasó eszközöket használ, például a Search Scripts és a Read Script eszközt, és semmit sem változtat a place-ben
  • Ha valamit javítani kell, megmondja, mit és hol változtatna meg, és felajánlja, hogy válts Build módra
  • Build módban helyben szerkeszti a scripteket, majd mindegyiket ellenőrzi a Check Scripttel. Ez fordítási ellenőrzés, nem típusellenőrzés és nem játékteszt
  • A Check Output eszközzel kiolvassa a Studio Outputját, az utolsó játékteszted Server és Client sorait is, még a Stop megnyomása után is

Build módban 3.9-es vagy újabb pluginnal a RoCode rövid játéktesztet indíthat és kiolvashatja a hibákat, 3.9.11-es vagy újabb pluginnal pedig irányíthat egy tesztkaraktert, de játék közben nem készít képernyőképeket, ezért a platformra továbbra is neked kell ráállnod. Hogyan csatlakozik a RoCode a Studióhoz.

Gyakori kérdések

Hol írjak scripteket a Roblox Studióban?

Az Explorerben vidd a kurzort egy tároló, például a ServerScriptService fölé, kattints a + gombra, és válaszd a Script lehetőséget. A Studio megnyitja a Script Editorban, ahol Luau kódot írsz. A szerverscriptek általában a ServerScriptService-ben vannak; a LocalScriptek a StarterPlayerScripts-ben vagy a StarterGui-ban.

Hogyan futtathatok egy scriptet a Roblox Studióban?

Nyomd meg a Play gombot (F5). A Studio elindít egy játéktesztet, és a ServerScriptService-ben vagy a Workspace-ben lévő minden bekapcsolt Script azonnal lefut a játék indulásakor; a StarterPlayerScripts-ben lévő LocalScriptek akkor futnak le, amikor belépsz a játéktesztbe. A Run (válaszd ki a Play melletti listában, vagy nyomd meg az F8-at) avatar nélkül indítja a játékot, ezért ehhez az útmutatóhoz a Play gombot használd. A Stop (Shift+F5) befejezi a tesztet. Egy meglévő script megnyitásához kattints rá duplán az Explorerben.

Milyen programozási nyelvet használ a Roblox?

A Luau nyelvet. A Roblox gyors, kicsi, biztonságos, fokozatos típusozású scriptnyelvként írja le, amely a Lua 5.1-ből származik, ezért a legtöbb Lua oktatóanyag ma is hasznos. A Luau olyan lehetőségeket ad hozzá, mint a backtickes stringinterpoláció és az opcionális típusannotációk, a Roblox pedig a saját könyvtárait és objektumait adja hozzá, például a task.wait-et.

Miben különbözik a Script a LocalScripttől?

A Script a szerveren fut, és a változtatásai minden játékoshoz eljutnak. A LocalScript egyetlen játékos eszközén fut, bevitelhez, kamerához és képernyős menükhöz, és a partokon, értékeken és a felületen végzett változtatásai ezen az eszközön maradnak. A kliensről és szerverről szóló útmutató (angolul) mindkettőt tárgyalja, plusz a ModuleScriptet.

Írhatok scripteket a Roblox Studióban telefonon vagy iPaden?

A Roblox telepítési oldala a Studiót ingyenes Windows- és Mac-alkalmazásként írja le, és nem említ telefonos vagy tabletes változatot, ezért a scripteléshez számítógép kell.

Miért nem csinál semmit a scriptem, és miért nem mutat hibát?

Általában olyan helyen van, ahol az ilyen script nem indul el (LocalScript a Workspace-ben vagy Script a StarterPlayerScripts-ben), ki van kapcsolva, vagy az esemény, amelyre vár, nem sül el. A hibákról szóló útmutatóban van egy ellenőrzőlista.

Mennyi idő alatt lehet megtanulni a Roblox scriptelést?

Őszinte számot senki sem tud mondani: attól függ, mennyit építesz. A legtöbbet az segít, ha gyakran írsz kis scripteket a saját place-edben. Módosítsd az itteni négy scriptet, próbáld ki a gyakorló feladatokat, aztán menj végig az első játékos útmutatón, és adj hozzá egyszerre egy rendszert.

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.