Tutorial · Basis van scripting

Hoe schrijf je scripts in Roblox Studio: handleiding voor beginners

Scripten, of programmeren, in Roblox Studio betekent Luau schrijven, de versie van de taal Lua van Roblox, in scripts die je aan je place toevoegt. Deze handleiding begint met een lege Baseplate: je opent het venster Output, schrijft je eerste script, verandert een part vanuit code, reageert op een speler die op een platform stapt en probeert een LocalScript, en onderweg leer je variabelen, functies, voorwaarden, loops en events kennen.

Bijgewerkt 20 november 202622 min lezenAuteur:

In het kort

Om een script te schrijven in Roblox Studio beweeg je je muis in de Explorer over ServerScriptService, klik je op + en voeg je een Script in. Studio opent het in de Script Editor. Schrijf Luau, bijvoorbeeld print("Hello"), klik op Play (F5) en lees het resultaat in het venster Output (menu Window of tabblad Script). Een Script draait op de server en verandert alles voor iedereen; een LocalScript in StarterPlayerScripts draait op het apparaat van één speler.

  • Leer eerst vier ideeën: variabelen (local coins = 3), functies (local function name() ... end), if-voorwaarden en events (part.Touched:Connect(...)). De vier scripts in deze handleiding zijn daaruit opgebouwd, plus loops en tables.
  • Gebruik task.wait(), niet wait(). De naslag van Roblox markeert de globale wait() als verouderd en vervangen door task.wait().
  • Zet in de weergave-instellingen van het venster Output Show Context aan, zodat elke regel laat zien of hij van de Server of de Client kwam.
Op deze pagina
  1. Voor je begint
  2. 1. Eerste script
  3. 2. Een part veranderen
  4. 3. Events
  5. 4. Eerste LocalScript
  6. 5. Testen
  7. Waar scripts horen
  8. Fouten lezen
  9. Oude tutorials
  10. Oefenen
  11. Wat nu
  12. Common errors
  13. Met RoCode
  14. Veelgestelde vragen
  15. Bronnen en verder lezen

Voor je begint: Studio, Baseplate en het venster Output

IllustratieVier scripts in één playtest: de part ColourChanger verandert elke seconde van kleur, een stap op Pad maakt hem 2 seconden geel voor alle spelers en schrijft je naam in Output, en E maakt Pad doorzichtiger, alleen op dit scherm.

Je hebt Roblox Studio en een Roblox-account nodig, verder niets: geen code-editor en geen plugin. Elk script in deze handleiding typ je in de eigen Script Editor van Studio.

  1. Installeer Roblox Studio, de gratis app van Roblox voor Windows en Mac, en log in met je Roblox-account.
  2. Open Studio. Op de startpagina staan templates: kies Baseplate. Je krijgt een vloer met een rastertextuur van 4x4 en een SpawnLocation, de plek waar je avatar verschijnt als je speelt.
  3. Zie je de vensters Explorer en Properties niet, open ze dan via het menu Window of het tabblad Home. Explorer toont alle objecten in de place; Properties toont de instellingen van wat je hebt geselecteerd.
  4. Open Output via het menu Window of het tabblad Script. Hier verschijnen de berichten en fouten van je scripts.
  5. Zet in de weergave-instellingen van het venster Output Show Context aan, dat elk bericht markeert als Client of Server, en Show Source, dat het script en het regelnummer laat zien waar het vandaan kwam.
De vier scripts die je gaat schrijven
ScriptTypeWaar het staatWat het je leert
FirstScriptScriptServerScriptServiceVariabelen, een functie, een if-voorwaarde, loops en een table
ColourChangerScriptIn een Part in WorkspaceEigenschappen veranderen, script.Parent en een loop met wachten
TouchPadScriptIn een Part met de naam PadEvents, de speler vinden die een part aanraakte, en debounce
MyFirstLocalScriptLocalScriptStarterPlayerScripts, in StarterPlayerCode op het apparaat van één speler, toetsaanslagen en wat op dat apparaat blijft
Explorer aan het einde (alleen de objecten uit deze handleiding)
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

Stap 1: schrijf je eerste script

  1. Beweeg in de Explorer je muis over ServerScriptService, klik op + en kies Script (sneltoets Ctrl+I, of ⌘I op een Mac). Studio maakt het script en opent het in de Script Editor.
  2. Klik met de rechtermuisknop op het nieuwe script, kies Rename en noem het FirstScript. De naam verandert niet wat het script doet, maar laat zien welk script wat heeft geprint.
  3. Nieuwe scripts beginnen met één regel, print("Hello world!"). Verwijder die en plak de code hieronder.
  4. Klik op Play (F5), met Test gekozen in de lijst links ervan. Studio start een playtest en zet je avatar op de SpawnLocation.
  5. Lees de regels in Output en klik dan op Stop (Shift+F5). Stop zet ook alle objecten terug in de staat van voor je op Play klikte, dus alles wat je tijdens het spelen hebt verschoven of anders gekleurd, komt terug.
Script in ServerScriptService met de naam FirstScript
-- Script in ServerScriptService met de naam FirstScript.
-- Je eerste Luau: variabelen, een functie, een if-voorwaarde, een loop en een table.
-- Klik op Play (F5) en lees het resultaat in het venster Output.

-- Een variabele is een naam die een waarde bewaart
local gameName = "Coin Run"
local coinsToWin = 3

-- Een functie is een blok code met een naam dat je zo vaak kunt uitvoeren als je wilt.
-- name en goal zijn de parameters; return geeft een waarde terug aan wie de functie aanriep.
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

-- Een if-voorwaarde voert code alleen uit als de voorwaarde waar is
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

-- Een for-loop herhaalt code een bepaald aantal keer
for count = 1, coinsToWin do
	print("Coin number", count)
end

-- Een table bewaart een lijst met waarden; deze loop loopt ze op volgorde langs
local colours = { "Red", "Green", "Blue" }
for position, colour in colours do
	print(position, colour) --> 1 Red, dan 2 Green, dan 3 Blue
end

Alles na -- op een regel is commentaar: Luau slaat het over, dus je kunt er notities voor jezelf in zetten. De opmerkingen met --> laten zien wat een regel print.

Output moet deze acht regels laten zien, tussen berichten van Studio zelf door. Als print meerdere waarden krijgt, zet het er een spatie tussen. Met Show Context en Show Source aan is elke regel ook gemarkeerd met Server en FirstScript met het regelnummer.

Output (verwacht)
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

Koppel elke regel aan de code die hem printte. Later doe je hetzelfde met foutmeldingen, dus die gewoonte komt van pas.

FirstScript gebruikt alleen pure Luau zonder Roblox-objecten, dus het werkt ook in de gratis Luau-playground in je browser. Verander daar een waarde en start opnieuw om te zien wat er verandert.

Wat elk deel van FirstScript doet
CodeIdeeWat het betekent
local gameName = "Coin Run"VariabeleEen naam die een waarde bewaart. local betekent dat alleen dit script of het blok waarin hij staat hem kan gebruiken. Tekst tussen aanhalingstekens is een string; 3 is een getal. Namen zijn hoofdlettergevoelig, dus coinsToWin en CoinsToWin zijn twee verschillende variabelen.
local function describe(name: string, goal: number): stringFunctieEen blok code met een naam dat je zo vaak kunt uitvoeren als je wilt. name en goal zijn de parameters: waarden die je bij elke aanroep meegeeft. : string en : number zijn optionele typeannotaties. Luau gebruikt ze om in de Script Editor voor fouten te waarschuwen; zonder werkt de code net zo.
returnReturnwaardeGeeft een waarde terug aan de code die de functie aanriep. print(describe(gameName, coinsToWin)) print wat describe teruggeeft.
`{name}: collect {goal} coins to win`StringinterpolatieTekst tussen backticks kan waarden bevatten: Luau vervangt {name} en {goal} door hun huidige waarden.
if, elseif, else, endIf-voorwaardeLuau controleert de voorwaarden van boven naar beneden en voert alleen de eerste ware uit. coinsToWin is 3, dat is niet meer dan 5 maar wel meer dan 1, dus alleen "That is a short game" wordt geprint.
for count = 1, coinsToWin doNumerieke for-loopVoert de code erin één keer uit voor elk getal van 1 tot coinsToWin, waarbij count 1 is, dan 2, dan 3.
{ "Red", "Green", "Blue" } en for position, colour in colours doTable en loopEen table als lijst, Luau noemt dat een array. Posities beginnen bij 1, niet bij 0. De loop loopt elk element langs en geeft zijn positie en waarde.

Elk blok dat opent met het woord function, if, for of while sluit af met het woord end. Eén vergeten end zorgt dat het hele script niet start; de sectie fouten lezen laat zien welke melding je dan krijgt.

Stap 2: verander een part vanuit een script

Scripts worden nuttig als ze iets in de wereld veranderen. De instellingen die je in het venster Properties ziet, zoals Color, Transparency of Anchored van een part, zijn eigenschappen, en een script kan ze ook instellen.

  1. Klik op het tabblad Home op Part. Studio voegt een blok toe aan Workspace. De naam maakt niet uit.
  2. Beweeg in de Explorer je muis over de nieuwe part, klik op + en voeg een Script in. Hernoem het naar ColourChanger en vervang de inhoud door de code hieronder.
  3. Klik op Play. De part wordt rood, dan blauw, dan groen, wisselt elke seconde en begint opnieuw.
Script in een willekeurige part in Workspace met de naam ColourChanger
-- Script in een Part in Workspace, met de naam ColourChanger.
-- Scripts veranderen dezelfde eigenschappen die je in het venster Properties ziet.
-- Dit script geeft zijn part elke seconde een nieuwe kleur, voor alle spelers.

local part = script.Parent :: BasePart -- de part waarin dit script staat

local colours = {
	Color3.fromRGB(255, 85, 85), -- rood
	Color3.fromRGB(85, 170, 255), -- blauw
	Color3.fromRGB(85, 255, 127), -- groen
}

part.Anchored = true -- een geankerde part blijft waar je hem neerzette

local index = 1
while true do
	part.Color = colours[index]
	index = index % #colours + 1 -- 1, 2, 3, dan weer 1
	task.wait(1) -- één seconde pauze (de oude wait() is verouderd)
end
  • script.Parent is het object waarin het script staat, hier de part. Sleep het script naar een andere part, en dan verandert het die.
  • :: BasePart is een type cast. Die vertelt de Script Editor dat de parent een part is, zodat hij de gebruikte eigenschappen kan controleren. Luau gebruikt types alleen voor waarschuwingen en suggesties, dus de cast verandert niet wat de regel doet.
  • part.Color en part.Anchored zijn dezelfde eigenschappen als in het venster Properties, met dezelfde namen. Roblox gebruikt Amerikaanse spelling, dus de eigenschap heet Color, ook al heet het script ColourChanger.
  • Anchored = true houdt de part op zijn plek: de naslag van Roblox zegt dat een geankerde part nooit beweegt door zwaartekracht, botsingen of andere physics.
  • colours[index] leest één element van de lijst. #colours is de lengte van de lijst, 3, en % geeft de rest van een deling, dus index % #colours + 1 telt 1, 2, 3, 1, 2, 3.
  • while true do herhaalt eindeloos, daarom is task.wait(1) erin zo belangrijk. De documentatie van Roblox zegt dat je altijd een vertraging zoals task.wait() in een oneindige loop moet zetten: zonder loopt de game vast en crasht Studio.

ColourChanger is een Script, dus het draait op de server, en alle spelers zien tegelijk dezelfde kleur. Stap 4 laat een ander soort script zien.

Stap 3: reageer op een speler met een event

De meeste gamecode wacht tot er iets gebeurt: een speler komt binnen, een part wordt aangeraakt, een knop wordt ingedrukt. Roblox noemt dat events. Om code uit te voeren als een event afgaat, verbind je er een functie mee.

  1. Voeg nog een Part in en hernoem hem precies naar Pad, met een hoofdletter P. Laat hem direct in Workspace staan, niet in een map of model, want het LocalScript in stap 4 zoekt hem daar.
  2. Maak er een plat platform van waar je op kunt staan, bijvoorbeeld door Size in het venster Properties op 6, 1, 6 te zetten. Zet hem op de vloer naast de SpawnLocation en vink Anchored aan, zodat hij niet beweegt.
  3. Beweeg je muis over Pad, klik op +, voeg een Script in, hernoem het naar TouchPad en plak de code hieronder.
  4. Klik op Play en ga op het platform staan. Het wordt 2 seconden geel, en Output noemt je naam.
Script in Workspace.Pad met de naam TouchPad
-- Script in een Part in Workspace met de naam Pad, script met de naam TouchPad.
-- Events: als een speler op het platform stapt, gloeit het geel en schrijft Output wie het was.
-- De debounce voorkomt dat de code vele keren per seconde afgaat terwijl de speler erop staat.

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 -- de cooldown na de vorige aanraking loopt nog
	end
	-- Het personage is de Model waarin het lichaamsdeel (of de hoed) zit dat het platform raakte
	local character = otherPart:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player then
		return -- een losse part of een NPC raakte het aan, geen speler
	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)
Hoe TouchPad van een aanraking bij een speler komt
CodeWat het doet
pad.Touched:Connect(onTouched)Verbindt de functie met het event Touched van het platform, dus Roblox voert onTouched uit elke keer dat iets het platform aanraakt, en geeft de part mee die het aanraakte.
otherPartDe part die het platform aanraakte: een voet, een been, het handvat van een hoed of een tool in de hand van een speler. Het is nooit de speler zelf, dus de volgende twee regels zoeken uit van wie hij is.
otherPart:FindFirstAncestorOfClass("Model")Gaat vanaf die part omhoog naar de eerste voorouder waarvan de class precies Model is, dus het personage. Omdat de classnaam precies moet kloppen, slaat hij een hoed (class Accessory) en een tool in de hand (class Tool) over.
Players:GetPlayerFromCharacter(character)Geeft de Player terug van wie dit personage is, of nil als het van niemand is, zoals een NPC. Het character and ervoor slaat de aanroep over als er geen model gevonden is, en dan blijft player nil.
if not player then return endStopt hier voor alles wat geen speler is. return verlaat de functie vroegtijdig.

Waarom het platform een debounce nodig heeft

De pagina van Roblox over debounce waarschuwt dat Touched een paar keer achter elkaar afgaat zolang parts elkaar raken, en een lopend personage heeft meerdere lichaamsdelen. Zonder controle kan één stap op het platform veel regels printen en de gele gloed steeds opnieuw starten.

De variabele busy is de debounce. De eerste aanraking zet hem op true, en elke aanraking in de 2 seconden daarna komt bij if busy then return end en stopt. Na task.wait(COOLDOWN_SECONDS) krijgt het platform zijn kleur terug en wordt busy weer false. COOLDOWN_SECONDS staat in hoofdletters omdat het een instelling is die tijdens het spelen niet verandert: zo raadt Roblox aan constanten te noemen.

Dit platform heeft één debounce voor iedereen, dus een tweede speler die binnen die 2 seconden erop stapt, wordt genegeerd. Voor een gloeiend platform is dat prima. Een platform dat beloningen geeft, moet een cooldown per speler bijhouden, zoals het muntenplatform in de handleiding over het leaderboard.

Stap 4: je eerste LocalScript en wat het anders maakt

Een draaiende game is één server plus een client per speler. Alles tot nu toe was een Script, dat op de server draait, dus de wijzigingen bereiken alle spelers. Een LocalScript draait op het apparaat van één speler. Toetsaanslagen, de camera en menu's op het scherm worden daar afgehandeld, omdat alleen dat apparaat ervan weet.

  1. Klap in de Explorer StarterPlayer open, beweeg je muis over StarterPlayerScripts, klik op + en voeg een LocalScript in. Hernoem het naar MyFirstLocalScript en plak de code hieronder.
  2. Klik op Play. Output laat Hello, en je naam zien, gemarkeerd als Client.
  3. Klik in het gamevenster en druk op E. Het platform wordt doorzichtiger. Druk nog eens op E om het terug te zetten.
  4. Klik tijdens de playtest op de schakelaar Client/Server bij de testknoppen van Studio om naar de serverkopie van de game te gaan. Daar is het platform niet doorzichtig: de server weet niets van de wijziging.
LocalScript in StarterPlayerScripts met de naam MyFirstLocalScript
-- LocalScript in StarterPlayer > StarterPlayerScripts met de naam MyFirstLocalScript.
-- Een LocalScript draait op het apparaat van één speler. Druk op E: Pad wordt doorzichtiger, alleen
-- op jouw scherm, omdat een wijziging aan een part van hieruit de server en anderen niet bereikt.

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

local player = Players.LocalPlayer
print(`Hello, {player.Name}`) -- verschijnt in Output, gemarkeerd als Client

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- de toets ging naar iets anders, bijvoorbeeld typen in de chat
	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)
  • Players.LocalPlayer is de speler op wiens apparaat het script draait. Roblox stelt het alleen in voor LocalScripts en de ModuleScripts die zij laden, dus servercode kan het niet gebruiken.
  • UserInputService.InputBegan gaat af als de speler begint met een toetsaanslag, klik of tik. gameProcessed is true als de engine die invoer al heeft gebruikt, bijvoorbeeld een klik op een knop of een toets in de chatbalk, dus het script negeert hem.
  • workspace:FindFirstChild("Pad") geeft het kind met de naam Pad terug, of nil als het er niet is. pad:IsA("BasePart") controleert dat het echt een part is, voordat het script zijn Transparency verandert.
  • if pad.Transparency == 0 then 0.6 else 0 is een if-expressie: die kiest een van twee waarden. Transparency 0 betekent volledig zichtbaar, 1 onzichtbaar.
  • Het sprintscript met Shift is een goed tweede LocalScript: het luistert naar een toets en verandert de WalkSpeed van het personage.
Script, LocalScript en ModuleScript
TypeWaar het draaitWaar wijzigingen terechtkomenWaarvoorStaat meestal in
ScriptOp de serverBij alle spelersSpelregels: munten, schade, deuren, rondes, opslaanServerScriptService, of in een part zolang je leert
LocalScriptOp het apparaat van één spelerAlleen op dat apparaat, behalve de beweging van het eigen personageInvoer, camera, menu's op het scherm, effecten voor één spelerStarterPlayerScripts of StarterGui
ModuleScriptAan de kant die er require() voor aanroeptHetzelfde als bij het script dat het laadtCode die meerdere scripts delenReplicatedStorage voor beide kanten, ServerScriptService alleen voor de server

Wat een valsspeler kan veranderen

Ga ervan uit dat een valsspeler alles op zijn eigen apparaat bestuurt. Hij kan zijn eigen LocalScripts draaien en de jouwe veranderen, dus hij kan het platform of wat dan ook op zijn scherm doorzichtig maken. Hier is dat onschuldig: de doorzichtigheid is alleen voor het oog en blijft op zijn apparaat. Precies daarom beslist een Script op de server over alles wat belangrijk is.

Een Script op de server is ook niet automatisch veilig. TouchPad draait op de server, maar het apparaat van elke speler bestuurt de physics van zijn personage, en de beveiligingsdocumentatie van Roblox noemt bij wat een client met parts onder zijn controle kan doen: bepalen wanneer Touched afgaat, of het helemaal blokkeren. Voor een gloeiend platform maakt dat niet uit. Bij een platform dat uitbetaalt, controleer je ook iets wat de server zelf bijhoudt, zoals de regel in de obby-handleiding dat checkpoints alleen op volgorde tellen.

Stap 5: test alle vier scripts samen

  1. Maak Output leeg met Ctrl+K (⌘K op een Mac) en klik op Play (F5). Output laat de acht regels van FirstScript zien, gemarkeerd als Server, en je regel Hello, gemarkeerd als Client. De part ColourChanger verandert elke seconde van kleur.
  2. Ga op het platform staan. Het wordt 2 seconden geel, en Output laat één keer je naam en "stepped on the pad" zien. Loop eroverheen: een nieuwe regel verschijnt hooguit eens per 2 seconden, niet bij elke keer dat Touched afgaat.
  3. Druk op E. Het platform wordt half doorzichtig (Transparency 0.6). Druk nog eens op E, en het is weer niet doorzichtig.
  4. Klik op Stop. Kies in de testlijst Server & Clients, zet 2 clients en klik op Play (of F7). Studio opent een servervenster en twee clientvensters. Druk in één client op E: het platform wordt daar doorzichtiger, terwijl de andere client en de server het niet doorzichtig laten zien. Klik op End Session als je klaar bent.
  5. Maak expres iets kapot. Hernoem Pad naar Pad2 en start de game. Een stap op het platform maakt het nog steeds geel, omdat TouchPad zijn part vindt via script.Parent, niet via de naam. Op E drukken doet nu niets, en er is geen fout: FindFirstChild("Pad") gaf nil terug, en de controle if pad and ... sloeg de rest stilletjes over. Zet print(pad) op de regel na FindFirstChild, start en druk op E: Output laat nil zien. Zo een print is de snelste manier om te snappen waarom een script niets doet. Stop de game, verwijder de regel met print en geef de part weer de naam Pad.

Waar je scripts zet

Waar een script staat, bepaalt of het überhaupt start, en Studio waarschuwt niet als het nooit start. Voor je volgende scripts:

Waar je elk soort script zet
ContainerWat je erin zetWaarom
ServerScriptServiceScripts met de meeste spelregels: beloningen, rondes, opslaanZe draaien op de server, en niets uit ServerScriptService wordt naar spelers gestuurd.
In een part in WorkspaceEen Script dat bij één part hoort, zoals ColourChanger en TouchPadPrima zolang je leert: de part is script.Parent. Voor echte projecten raadt Roblox aan in plaats daarvan parts te taggen (zie hieronder).
StarterPlayerScripts, in StarterPlayerDe meeste LocalScripts: invoer, camera, effecten voor één spelerElke speler krijgt bij het binnenkomen een eigen kopie.
StarterGuiLocalScripts in een ScreenGui die een menu op het scherm besturenElke speler krijgt een eigen kopie van de interface.
ReplicatedStorageModuleScripts die zowel server- als clientcode laadtBeide kanten zien het. Een LocalScript of Script met standaardinstellingen start hier nooit.

De pagina van Roblox over de plek van scripts raadt aan om helemaal geen scripts direct in parts in Workspace te zetten: tag de parts en werk ermee vanuit één ModuleScript via CollectionService. Een script in een part is toch de makkelijkste start, en voor een of twee objecten is dat prima zolang je leert. De handleiding over deuren laat het patroon met tags zien, met één script voor alle deuren, en de handleiding over client en server heeft de volledige tabel van welke containers welke scripts starten.

Als er iets misgaat: lees Output

Fouten verschijnen rood in Output. Elke fout begint met waar hij gebeurde, de volledige naam van het script en het regelnummer, en zegt daarna wat er mis is. Klik op de fout, en Studio opent het script op die regel. Als je bijvoorbeeld de controle if not player uit TouchPad haalt en er valt een losse part op het platform, laat Output dit zien:

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

Fouten in hoe de code geschreven is, zoals een vergeten end, zie je al voordat je op Play klikt: de Script Editor onderstreept ze rood, en het venster Script Analysis (knop Analysis op het tabblad Script) zet ze op een rij. Een script met zo een fout start helemaal niet, ook de regels erboven niet.

Drie fouten die je moet leren herkennen
MeldingWat het betekentHoe je het oplost
Colour is not a valid member of Part "Workspace.Part"Dit object heeft niets met precies die naam. Hier wordt de eigenschap Color geschreven.Vergelijk de spelling en hoofdletters met het venster Properties of Explorer. Meer over deze fout.
attempt to index nil with 'Name'De code las iets, hier .Name, van een waarde nil. In het voorbeeld hierboven was player nil, omdat een losse part het platform raakte.Zoek uit waarom de waarde nil is, en controleer hem met if voordat je hem gebruikt. Meer over deze fout.
Expected 'end' (to close 'then' at line 2), got <eof>De if op regel 2 heeft geen bijbehorende end. Bij een functie zegt de melding to close 'function', en <eof> betekent het einde van het bestand.Voeg de vergeten end toe, en ga uit van de regel tussen haakjes, niet van de laatste. Soms eindigt de melding met "did you forget to close ... at line N?". Dat is een gok van Luau op basis van inspringing, en die kan naar het verkeerde blok wijzen, dus controleer eerst de regel tussen haakjes. Meer over syntaxfouten.

Als een script niets doet en Output ook leeg is, staat het script meestal op een plek waar het nooit start, of wacht het op een event dat niet afgaat. De handleiding over fouten heeft een checklist voor stille scripts en meer over Output lezen.

Wat oude scripting-tutorials anders doen

Leer je ook van video's en forumposts, dan kom je oude patronen tegen. Hier zijn de belangrijkste, met de reden waarom elk een probleem is.

Patronen uit oude tutorials en wat deze handleiding in plaats daarvan doet
TutorialProbleemDeze handleiding
Pauzeert met wait(1)De naslag van Roblox markeert de globale wait() als verouderd en zegt dat task.wait() hem heeft vervangen.task.wait(1)
Vindt het personage via otherPart.Parent, zoals in de les van Roblox over lavaAls een hoed of een tool in de hand de part raakt, is otherPart.Parent een Accessory of Tool en niet het personage, dus de Humanoid wordt niet gevonden en de aanraking gaat verloren.FindFirstAncestorOfClass("Model"), daarna GetPlayerFromCharacter
Gebruikt Touched zonder debounceTouched gaat bij één stap een paar keer achter elkaar af, dus de code draait steeds opnieuw.Een vlag busy en een cooldown
Zet een LocalScript in een part in WorkspaceEen LocalScript start daar nooit. Het draait alleen vanaf plekken die bij één speler horen.Een LocalScript in StarterPlayerScripts (waarom)
Schrijft part.Touched:connect(...) of table.getn(list)De naamgevingsgids van Roblox zegt dat API's in camelCase grotendeels verouderd zijn, en de naslag noemt alleen Connect. table.getn is verouderd ten gunste van #list.:Connect(...) en #list
Verandert munten of doet schade in een LocalScriptDe wijziging blijft op het apparaat van die speler, dus niemand anders ziet hem en de server telt hem niet mee.Spelregels in een Script op de server

Oefenen: drie wijzigingen om te proberen

Code veranderen leert je meer dan code lezen. Probeer deze een voor een in je eigen place en klik na elke wijziging op Play.

  • Laat het platform een punt geven. Voeg het script Leaderstats toe uit stap 1 van de handleiding over het leaderboard. Zoek daarna in TouchPad na busy = true de map leaderstats van de speler op en tel 1 op bij de waarde Coins. Tip: player:FindFirstChild("leaderstats"), daarna leaderstats:FindFirstChild("Coins"), daarna coins.Value += 1. Het muntenplatform in de handleiding over het leaderboard is de kant-en-klare versie, met een cooldown per speler.
  • Laat ColourChanger ook de doorzichtigheid veranderen. Zorg dat ColourChanger elke seconde ook de Transparency van de part verandert. Tip: voeg een tweede table met getallen van 0 tot 1 toe, bijvoorbeeld { 0, 0.3, 0.6 }, en stel daarmee part.Transparency in op de regel na part.Color, met dezelfde index.
  • Print de kleur van het platform. Laat MyFirstLocalScript de Color van het platform printen als je op E drukt. Tip: print(pad.Color) binnen het blok if pad and pad:IsA("BasePart"). Druk op E terwijl het platform geel is: de client ziet de kleur die de server instelde, omdat wijzigingen op de server alle clients bereiken.

Wat je hierna leert

Je hebt nu de onderdelen gebruikt waaruit de meeste gamescripts zijn opgebouwd. Een goede volgorde om verder te gaan:

  1. LocalScript vs Script vs ModuleScript: waar elk type script draait en wat het kan veranderen, dieper dan stap 4.
  2. RemoteEvents: hoe een LocalScript de server vraagt iets te doen en hoe de server het verzoek controleert.
  3. Leaderboard: je eerste stats, gemaakt en veranderd op de server.
  4. Je eerste game: een korte baan met lava, munten en een finishplatform met twee serverscripts, en daarna publiceren.
  5. Kies daarna een systeem: een shop-GUI, een rondesysteem, checkpoints in een obby, een laadscherm of een animatie bij een toetsaanslag. Als er iets stukgaat, helpt de handleiding over scriptfouten je de melding te lezen. De handleiding over checkpoints is voorlopig in het Engels.

De eigen tutorials van Roblox, Coding fundamentals (in het Engels), zijn een goede aanvulling op deze handleiding: zes reeksen, van variabelen en functies via voorwaarden, loops, arrays en dictionaries tot het ordenen van code in ModuleScripts, met kleine projecten in Studio.

Veelvoorkomende fouten en oplossingen

De meeste problemen met je eerste scripts zijn een naam die niet klopt, een script op de verkeerde plek of een loop zonder wachten. Houd Output open tijdens het testen.

Studio loopt vast of reageert niet meer als ik op Play klik

In een loop while true do zit geen wachten, dus verder kan er niets draaien. De documentatie van Roblox zegt dat een oneindige loop zonder vertraging zoals task.wait() de game laat vastlopen en Studio laat crashen. Zet task.wait() in elke oneindige loop, zoals in ColourChanger.

Er gebeurt niets als ik op het platform ga staan

Controleer dat TouchPad een Script is en geen LocalScript, direct in de part Pad staat, niet uitgeschakeld is, en dat de eigenschap CanTouch van het platform aangevinkt is. Zet daarna print("touched", otherPart.Name) als eerste regel binnen onTouched. Wordt dat niet geprint, dan gaat het event niet af; wordt het wel geprint, dan zit het probleem lager.

Op E drukken doet niets

MyFirstLocalScript moet een LocalScript in StarterPlayerScripts zijn: een LocalScript in Workspace of ServerScriptService start nooit. De part moet precies Pad heten en direct in Workspace staan. Klik eerst in het gamevenster en zorg dat je niet in de chat typt, want het script negeert toetsen die de game al heeft gebruikt.

De part verandert op mijn scherm, maar niet bij andere spelers

Een LocalScript heeft de wijziging gedaan, dus die bleef op jouw apparaat. Doe het in een Script op de server, of laat het LocalScript de server vragen via een RemoteEvent.

ColourChanger werkt in een part, maar gaat stuk in ServerScriptService

Het gebruikt script.Parent als zijn part. In ServerScriptService is de parent ServerScriptService, die geen Anchored of Color heeft, dus Output laat een fout "not a valid member" zien. Houd het in een part, of geef de part een naam en zoek hem op naam, bijvoorbeeld local part = workspace:WaitForChild("ColourPart") :: BasePart.

Output laat helemaal niets zien

Controleer dat het venster Output open is (menu Window of tabblad Script) en dat er geen filter aan staat: Output kun je filteren op soort bericht, op Client of Server en op tekst. Is het open en toch leeg, dan is het script waarschijnlijk niet gestart. Zie de checklist voor scripts die niets doen.

Vastgelopen? RoCode

Zit je vast met een script in je eigen place, dan kan RoCode het samen met je doorlopen. RoCode is een onafhankelijke AI-agent voor Roblox Studio, niet van Roblox: je schrijft in een webchat, en de plugin voor Studio maakt en bewerkt scripts in je Explorer.

Zolang je leert, is de modus Ask handig: jij schrijft de scripts, en RoCode leest wat er al is en beantwoordt vragen.

Jij typt

Leg regel voor regel uit wat het script TouchPad in de part Pad doet, en waarom het een debounce gebruikt.

RoCode doet
  • Gebruikt in de modus Ask alleen leestools, zoals Search Scripts en Read Script, en verandert niets in de place
  • Moet er iets gerepareerd worden, dan zegt hij wat en waar hij het zou veranderen, en stelt hij voor om over te schakelen naar Build
  • Bewerkt in de modus Build scripts ter plekke en controleert daarna elk script met Check Script. Dat is een compileercontrole, geen typecontrole en geen playtest
  • Leest de Output van Studio met de tool Check Output, inclusief de regels Server en Client van je laatste playtest, ook nadat je op Stop hebt geklikt

In de modus Build met plugin 3.9 of nieuwer kan RoCode een korte playtest draaien en de fouten lezen, en met 3.9.11 of nieuwer een testpersonage besturen, maar tijdens het spelen maakt hij geen screenshots, dus op het platform ga je toch zelf staan. Hoe RoCode verbinding maakt met Studio.

Veelgestelde vragen

Waar schrijf je scripts in Roblox Studio?

Beweeg in de Explorer je muis over een container, bijvoorbeeld ServerScriptService, klik op + en kies Script. Studio opent het in de Script Editor, waar je Luau schrijft. Serverscripts staan meestal in ServerScriptService; LocalScripts in StarterPlayerScripts of StarterGui.

Hoe start je een script in Roblox Studio?

Klik op Play (F5). Studio start een playtest, en elk ingeschakeld Script in ServerScriptService of Workspace draait meteen bij de start van de game; LocalScripts in StarterPlayerScripts draaien als je de playtest binnenkomt. Run (kies het in de lijst naast Play of druk op F8) start de game zonder avatar, dus gebruik voor deze handleiding Play. Stop (Shift+F5) beëindigt de test. Om een bestaand script te openen, dubbelklik je erop in de Explorer.

Welke programmeertaal gebruikt Roblox?

Luau. Roblox beschrijft het als een snelle, kleine, veilige scripttaal met geleidelijke typering, afgeleid van Lua 5.1, dus de meeste tutorials over Lua zijn nog steeds nuttig. Luau voegt dingen toe zoals stringinterpolatie met backticks en optionele typeannotaties, en Roblox voegt eigen bibliotheken en objecten toe, zoals task.wait.

Wat is het verschil tussen een Script en een LocalScript?

Een Script draait op de server, en de wijzigingen bereiken alle spelers. Een LocalScript draait op het apparaat van één speler, voor invoer, camera en menu's op het scherm, en zijn wijzigingen aan parts, waarden en interface blijven op dat apparaat. De handleiding over client en server (in het Engels) behandelt beide, plus ModuleScript.

Kun je scripts schrijven in Roblox Studio op een telefoon of iPad?

De installatiepagina van Roblox beschrijft Studio als gratis app voor Windows en Mac en noemt geen versie voor telefoon of tablet, dus om te scripten heb je een computer nodig.

Waarom doet mijn script niets en laat het geen fout zien?

Meestal staat het op een plek waar zo een script niet start (een LocalScript in Workspace of een Script in StarterPlayerScripts), is het uitgeschakeld, of gaat het event waarop het wacht niet af. De handleiding over fouten heeft een checklist.

Hoe lang duurt het om scripten in Roblox te leren?

Niemand kan je een eerlijk getal geven: het hangt af van hoeveel je bouwt. Wat het meest helpt, is vaak kleine scripts schrijven in je eigen place. Verander de vier scripts van hier, probeer de oefeningen en doorloop daarna de handleiding over je eerste game, waarbij je er telkens één systeem aan toevoegt.

Bronnen en verder lezen

Hoe de code is gecontroleerd: elk script op deze pagina doorloopt een strikte Luau-typecontrole met de Roblox API-definities (luau-lsp, 20 november 2026). De typecontrole vangt fouten in API-namen en verkeerde types op, maar geen fouten in de gamelogica, dus test alles in Studio voordat je publiceert.

Probeer RoCode in je eigen game.

Elke dag gratis credits, geen creditcard nodig. Installeer de plugin, beschrijf een functie en kijk wat er in Studio verschijnt.