Roblox Scripting für Anfänger: so programmierst du in Roblox Studio

Bevor du anfängst: Studio, eine Baseplate und das Output-Fenster

Du brauchst Roblox Studio und ein Roblox-Konto, sonst nichts: keinen Code-Editor und kein Plugin. Jedes Skript in diesem Guide wird im eigenen Script Editor von Studio getippt.

1. Installier Roblox Studio, die kostenlose App von Roblox für Windows und Mac, und melde dich mit deinem Roblox-Konto an.
2. Öffne Studio. Die Startseite listet Vorlagen: Wähl Baseplate. Du bekommst einen Boden mit einer 4x4-Rastertextur und eine SpawnLocation, die Stelle, an der dein Avatar beim Spielen erscheint.
3. Sind die Fenster Explorer und Properties nicht zu sehen, öffne sie über das Menü Window oder den Tab Home. Der Explorer listet jedes Objekt in deinem Spiel; Properties zeigt die Einstellungen dessen, was du auswählst.
4. Öffne Output über das Menü Window oder den Tab Script. Hier erscheinen die Nachrichten und Fehler deiner Skripte.
5. Schalte in den Anzeigeoptionen des Output-Fensters Show Context ein, das jede Nachricht als Client oder Server kennzeichnet, und Show Source, das Skript und Zeilennummer zeigt, von denen sie kommt.

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

Schritt 1: Dein erstes Skript schreiben

1. Fahr im Explorer mit der Maus über ServerScriptService, klick auf + und wähl Script (Kurzbefehl Strg+I, auf dem Mac ⌘I). Studio erstellt das Skript und öffnet es im Script Editor.
2. Klick mit der rechten Maustaste auf das neue Skript, wähl Rename und nenn es FirstScript. Der Name ändert nicht, was das Skript macht, aber er sagt dir, welches Skript was ausgegeben hat.
3. Neue Skripte beginnen mit einer Zeile, print("Hello world!"). Lösch sie und füge den Code unten ein.
4. Drück auf Play (F5), mit Test im Dropdown links daneben. Studio startet einen Playtest und setzt deinen Avatar auf die SpawnLocation.
5. Lies die Zeilen im Output und drück dann auf Stop (Shift+F5). Stop setzt außerdem jedes Objekt in den Zustand vor dem Drücken auf Play zurück, also geht alles, was du beim Spielen bewegt oder umgefärbt hast, wieder zurück.

-- Script in ServerScriptService namens FirstScript.
-- Dein erstes Luau: Variablen, eine Funktion, eine if-Abfrage, eine Schleife und eine Tabelle.
-- Drück auf Play (F5) und lies die Ergebnisse im Output-Fenster.

-- Eine Variable ist ein Name, der einen Wert hält
local gameName = "Coin Run"
local coinsToWin = 3

-- Eine Funktion ist ein benannter Codeblock, den du so oft ausführen kannst, wie du willst.
-- name und goal sind ihre Parameter; return gibt einen Wert an den Aufrufer zurück.
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

-- Eine if-Abfrage führt Code nur aus, wenn ihre Bedingung wahr ist
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

-- Eine for-Schleife wiederholt Code eine bestimmte Anzahl von Malen
for count = 1, coinsToWin do
	print("Coin number", count)
end

-- Eine Tabelle hält eine Liste von Werten; diese Schleife besucht jeden der Reihe nach
local colours = { "Red", "Green", "Blue" }
for position, colour in colours do
	print(position, colour) --> 1 Red, dann 2 Green, dann 3 Blue
end

Der Output sollte diese acht Zeilen zeigen, gemischt mit Nachrichten von Studio selbst. Bekommt print mehr als einen Wert, setzt es ein Leerzeichen dazwischen. Mit Show Context und Show Source ist jede Zeile außerdem mit Server und FirstScript samt Zeilennummer gekennzeichnet.

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

Ordne jede Zeile dem Code zu, der sie ausgegeben hat. Später machst du dasselbe mit Fehlermeldungen, also lohnt sich die Gewohnheit jetzt schon.

FirstScript nutzt nur reines Luau ohne Roblox-Objekte, also läuft es auch im kostenlosen Luau-Playground in deinem Browser. Ändere dort einen Wert und führ es noch einmal aus, um zu sehen, was sich ändert.

Jeder Block, der mit function, if, for oder while beginnt, endet mit end. Ein einziges fehlendes end verhindert, dass das ganze Skript läuft; Fehler lesen zeigt die Meldung, die du dann bekommst.

Schritt 2: Einen Part per Skript ändern

Skripte werden nützlich, wenn sie Dinge in der Welt ändern. Die Einstellungen, die du im Properties-Fenster siehst, zum Beispiel Color, Transparency oder Anchored eines Parts, sind Eigenschaften, und ein Skript kann sie ebenfalls setzen.

1. Klick im Tab Home auf Part. Studio fügt dem Workspace einen Block hinzu. Sein Name ist egal.
2. Fahr im Explorer mit der Maus über den neuen Part, klick auf + und füge ein Script ein. Nenn es ColourChanger und ersetz seinen Inhalt durch den Code unten.
3. Drück auf Play. Der Part wird rot, dann blau, dann grün, einmal pro Sekunde, und fängt wieder von vorn an.

-- Script in einem Part in Workspace, namens ColourChanger.
-- Skripte ändern dieselben Eigenschaften, die du im Properties-Fenster siehst.
-- Dieses gibt seinem Part jede Sekunde eine neue Farbe, für jeden Spieler.

local part = script.Parent :: BasePart -- der Part, in dem dieses Skript steckt

local colours = {
	Color3.fromRGB(255, 85, 85), -- rot
	Color3.fromRGB(85, 170, 255), -- blau
	Color3.fromRGB(85, 255, 127), -- grün
}

part.Anchored = true -- ein verankerter Part bleibt, wo du ihn hingestellt hast

local index = 1
while true do
	part.Color = colours[index]
	index = index % #colours + 1 -- 1, 2, 3, dann zurück zu 1
	task.wait(1) -- eine Sekunde Pause (das alte wait() ist veraltet)
end

• script.Parent ist das Objekt, in dem das Skript steckt, hier der Part. Zieh das Skript in einen anderen Part, und es ändert stattdessen diesen.
• :: BasePart ist ein Type Cast. Er sagt dem Script Editor, dass der Parent ein Part ist, damit er die Eigenschaften prüfen kann, die du daran nutzt. Luau nutzt Typen nur für Warnungen und Vorschläge, also ändert der Cast nicht, was die Zeile macht.
• part.Color und part.Anchored sind dieselben Eigenschaften, die du im Properties-Fenster siehst, mit denselben Namen. Roblox nutzt amerikanische Schreibweise, also heißt die Eigenschaft Color, obwohl dieses Skript ColourChanger heißt.
• Anchored = true hält den Part still: Laut der Referenz von Roblox bewegt sich ein verankerter Part nie durch Schwerkraft, Kollisionen oder andere Physik.
• colours[index] liest ein Element aus der Liste. #colours ist die Länge der Liste, 3, und % gibt den Rest nach dem Teilen, also zählt index % #colours + 1 1, 2, 3, 1, 2, 3.
• while true do wiederholt für immer, deshalb ist das task.wait(1) darin wichtig. Laut der Dokumentation von Roblox gehört in eine Endlosschleife immer eine Verzögerung wie task.wait(): Ohne sie friert das Spiel ein und Studio stürzt ab.

ColourChanger ist ein Script, also läuft es auf dem Server, und jeder Spieler im Spiel sieht dieselbe Farbe zur selben Zeit. Schritt 4 zeigt die andere Art von Skript.

Schritt 3: Mit einem Event auf einen Spieler reagieren

Der meiste Spielcode wartet darauf, dass etwas passiert: Ein Spieler tritt bei, ein Part wird berührt, ein Button wird geklickt. Roblox nennt das Events. Um Code auszuführen, wenn eines ausgelöst wird, verbindest du eine Funktion damit.

1. Füge einen weiteren Part ein und nenn ihn genau Pad, mit großem P. Lass ihn direkt im Workspace, nicht in einem Ordner oder Modell, weil das LocalScript in Schritt 4 ihn dort sucht.
2. Mach eine flache Platte daraus, auf die du laufen kannst, zum Beispiel indem du im Properties-Fenster Size auf 6, 1, 6 setzt. Schieb sie auf den Boden in die Nähe der SpawnLocation und hak Anchored an, damit sie bleibt, wo sie ist.
3. Fahr mit der Maus über Pad, klick auf +, füge ein Script ein, nenn es TouchPad und füge den Code unten ein.
4. Drück auf Play und lauf auf die Platte. Sie wird für 2 Sekunden gelb, und der Output nennt deinen Namen.

-- Script in einem Part in Workspace namens Pad, Skript namens TouchPad.
-- Events: Wenn ein Spieler auf das Pad tritt, leuchtet es gelb und der Output sagt, wer es war.
-- Ein Debounce verhindert, dass es mehrmals pro Sekunde läuft, während er darauf steht.

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 -- kühlt noch von der letzten Berührung ab
	end
	-- Die Figur ist das Model, das den Körperteil (oder Hut) hält, der das Pad berührt hat
	local character = otherPart:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player then
		return -- ein loser Part oder ein NPC hat es berührt, kein Spieler
	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)

Warum das Pad ein Debounce braucht

Die Debounce-Seite von Roblox warnt, dass Touched mehrmals kurz hintereinander feuert, wenn Parts sich berühren, und eine laufende Figur hat mehrere Körperteile. Ohne Prüfung könnte ein einziger Schritt auf das Pad viele Zeilen ausgeben und das gelbe Leuchten immer wieder neu starten.

Die Variable busy ist das Debounce. Die erste Berührung setzt sie auf true, und jede Berührung in den nächsten 2 Sekunden erreicht if busy then return end und hört auf. Nach task.wait(COOLDOWN_SECONDS) wechselt das Pad zurück, und busy wird wieder false. COOLDOWN_SECONDS ist in Großbuchstaben geschrieben, weil es eine Einstellung ist, die sich während des Spiels nicht ändert, die Schreibweise, die Roblox für Konstanten vorschlägt.

Dieses Pad hat ein Debounce für alle, also wird ein zweiter Spieler, der innerhalb dieser 2 Sekunden darauf tritt, ignoriert. Für ein Pad, das leuchtet, ist das in Ordnung. Ein Pad, das Belohnungen gibt, sollte stattdessen einen Cooldown pro Spieler haben, wie das Münz-Pad im Leaderboard-Guide (auf Englisch).

Schritt 4: Dein erstes LocalScript, und warum es anders ist

Ein laufendes Spiel besteht aus einem Server plus einem Client für jeden Spieler. Alles bisher war ein Script, das auf dem Server läuft, also erreichen seine Änderungen jeden Spieler. Ein LocalScript läuft stattdessen auf dem Gerät eines Spielers. Tastendrücke, die Kamera und Menüs auf dem Bildschirm werden dort behandelt, weil nur dieses Gerät davon weiß.

1. Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts, klick auf + und füge ein LocalScript ein. Nenn es MyFirstLocalScript und füge den Code unten ein.
2. Drück auf Play. Der Output zeigt Hello, und deinen Namen, gekennzeichnet mit Client.
3. Klick in die Spielansicht und drück E. Das Pad wird durchsichtig. Drück noch einmal E, um es zurückzuholen.
4. Klick, während der Playtest noch läuft, in den Test-Steuerelementen von Studio auf den Umschalter Client/Server, um zur Kopie des Servers zu wechseln. Dort ist das Pad massiv: Der Server hat von der Änderung nie erfahren.

-- LocalScript in StarterPlayer > StarterPlayerScripts namens MyFirstLocalScript.
-- Ein LocalScript läuft auf dem eigenen Gerät eines Spielers. Drück E: Das Pad wird nur auf deinem
-- Bildschirm durchsichtig, weil eine Änderung an einem Part von hier weder den Server noch sonst jemanden erreicht.

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

local player = Players.LocalPlayer
print(`Hello, {player.Name}`) -- erscheint im Output, als Client gekennzeichnet

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- die Taste wurde für etwas anderes genutzt, zum Beispiel Tippen im 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 ist der Spieler, auf dessen Gerät das Skript läuft. Roblox definiert es nur für LocalScripts und die ModuleScripts, die sie laden, also kann Server-Code es nicht nutzen.
• UserInputService.InputBegan feuert, wenn der Spieler einen Tastendruck, einen Klick oder eine Berührung beginnt. gameProcessed ist true, wenn die Engine diese Eingabe schon genutzt hat, zum Beispiel einen Klick auf einen Button oder eine Taste im Chat, also ignoriert das Skript sie.
• workspace:FindFirstChild("Pad") gibt das Kind namens Pad zurück oder nil, wenn es keins gibt. pad:IsA("BasePart") prüft, ob es wirklich ein Part ist, bevor das Skript seine Transparency ändert.
• if pad.Transparency == 0 then 0.6 else 0 ist ein if-Ausdruck: Er wählt einen von zwei Werten. Eine Transparency von 0 ist voll sichtbar, 1 ist unsichtbar.
• Ein Sprint-Skript mit Shift (auf Englisch) ist ein gutes zweites LocalScript: Es hört auf eine Taste und ändert die WalkSpeed deiner Figur.

Was ein Cheater ändern kann

Geh davon aus, dass ein Cheater alles auf seinem eigenen Gerät kontrolliert. Er kann eigene LocalScripts ausführen und deine ändern, also kann er das Pad oder alles andere auf seinem eigenen Bildschirm durchsichtig machen. Hier ist das harmlos: Das Ausblenden ist nur Optik und bleibt auf seinem Gerät. Genau deshalb wird alles, was zählt, von einem Script auf dem Server entschieden.

Auch ein Server-Script ist nicht automatisch sicher. TouchPad läuft auf dem Server, aber das Gerät jedes Spielers steuert die Physik seiner eigenen Figur, und die Sicherheitsdokumentation von Roblox nennt es unter den Dingen, die ein Client mit seinen Parts tun kann, zu manipulieren, wann Touched feuert, oder es ganz zu verhindern. Für ein Pad, das leuchtet, ist das egal. Für ein Pad, das etwas auszahlt, prüf zusätzlich etwas, das der Server selbst verfolgt, wie die Regel im Obby-Guide (auf Englisch), dass Checkpoints nur der Reihe nach zählen.

Schritt 5: Alle vier Skripte zusammen testen

1. Leer den Output mit Strg+K (⌘K auf dem Mac) und drück auf Play (F5). Der Output zeigt die acht Zeilen von FirstScript mit Server gekennzeichnet und deine Hello-Zeile mit Client. Der Part ColourChanger wechselt jede Sekunde die Farbe.
2. Lauf auf das Pad. Es wird für 2 Sekunden gelb, und der Output zeigt einmal deinen Namen und „stepped on the pad“. Lauf weiter darauf herum: Eine neue Zeile erscheint höchstens alle 2 Sekunden, nicht jedes Mal, wenn Touched feuert.
3. Drück E. Das Pad wird auf eine Transparency von 0.6 durchsichtig. Drück noch einmal E, und es ist massiv.
4. Drück auf Stop. Wähl im Test-Dropdown Server & Clients, stell 2 Clients ein und drück auf Play (oder F7). Studio öffnet ein Server-Fenster und zwei Client-Fenster. Drück in einem Client E: Das Pad wird dort durchsichtig, während der andere Client und der Server es weiter massiv zeigen. Drück auf End Session, wenn du fertig bist.
5. Mach absichtlich etwas kaputt. Benenn Pad in Pad2 um und spiel. Drauflaufen macht es weiterhin gelb, weil TouchPad seinen Part über script.Parent findet, nicht über den Namen. E macht jetzt nichts, und es gibt keinen Fehler: FindFirstChild("Pad") hat nil zurückgegeben, und die Prüfung if pad and ... hat den Rest still übersprungen. Füge in der Zeile nach FindFirstChild ein print(pad) ein, spiel und drück E: Der Output zeigt nil. So ein print ist der schnellste Weg herauszufinden, warum ein Skript nichts tut. Drück auf Stop, lösch die print-Zeile und benenn den Part wieder in Pad um.

Wo Skripte hingehören

Wo ein Skript liegt, entscheidet, ob es überhaupt läuft, und Studio warnt dich nicht, wenn es nie laufen wird. Für die Skripte, die du als Nächstes schreibst:

Die Seite zu Skript-Orten von Roblox empfiehlt, Skripte gar nicht direkt in Parts in Workspace zu legen: Tagge die Parts stattdessen und arbeite mit ihnen aus einem einzigen ModuleScript über CollectionService. Ein Skript in einem Part ist trotzdem der einfachste Einstieg und für ein oder zwei Objekte beim Lernen in Ordnung. Der Tür-Guide zeigt das Muster mit Tags, mit einem Skript für jede Tür, und der Client-und-Server-Guide hat die vollständige Tabelle, welche Container welche Skripte ausführen (beide auf Englisch).

Wenn etwas schiefgeht: den Output lesen

Fehler erscheinen im Output in Rot. Jeder beginnt damit, wo er passiert ist, mit dem vollen Namen des Skripts und der Zeilennummer, und sagt dann, was schiefging. Klick auf den Fehler, und Studio öffnet das Skript an dieser Zeile. Hättest du zum Beispiel die Prüfung if not player aus TouchPad gelöscht und ein loser Part wäre auf dem Pad gelandet, würde der Output zeigen:

Workspace.Pad.TouchPad:22: attempt to index nil with 'Name'

Fehler in der Schreibweise des Codes, zum Beispiel ein fehlendes end, zeigen sich schon vor dem Drücken auf Play: Der Script Editor unterstreicht sie rot, und das Fenster Script Analysis (der Button Analysis im Tab Script) listet sie. Ein Skript mit so einem Fehler läuft gar nicht, nicht einmal die Zeilen darüber.

Wenn ein Skript nichts tut und der Output auch nichts zeigt, liegt es meist irgendwo, wo es nie läuft, oder wartet auf ein Event, das nie feuert. Der Guide zu Skriptfehlern hat eine Checkliste für stille Skripte und geht tiefer darauf ein, wie man den Output liest (auf Englisch).

Was ältere Scripting-Tutorials anders machen

Wenn du auch mit Videos und Forenbeiträgen lernst, triffst du auf ältere Muster. Das sind die wichtigen, jeweils mit dem Grund, warum sie ein Problem sind.

Übung: drei Änderungen zum Ausprobieren

Code zu ändern bringt mehr, als ihn zu lesen. Probier diese in deinem eigenen Spiel aus, eine nach der anderen, und drück nach jeder auf Play.

• Lass das Pad einen Punkt geben. Füge das Leaderstats-Skript aus Schritt 1 des Leaderboard-Guides (auf Englisch) hinzu. Such dann in TouchPad nach busy = true den Ordner leaderstats des Spielers und erhöh seinen Wert Coins um 1. Tipp: player:FindFirstChild("leaderstats"), dann leaderstats:FindFirstChild("Coins"), dann coins.Value += 1. Das Münz-Pad im Leaderboard-Guide ist eine fertige Version, mit einem Cooldown pro Spieler.
• Lass auch den Farbwechsler verblassen. Lass ColourChanger zusätzlich jede Sekunde die Transparency des Parts ändern. Tipp: Füge eine zweite Tabelle mit Zahlen zwischen 0 und 1 hinzu, zum Beispiel { 0, 0.3, 0.6 }, und setz part.Transparency in der Zeile nach part.Color daraus, mit demselben index.
• Gib die Farbe des Pads aus. Lass MyFirstLocalScript beim Drücken von E die Color des Pads ausgeben. Tipp: print(pad.Color) im Block if pad and pad:IsA("BasePart"). Drück E, während das Pad gelb ist: Der Client sieht die Farbe, die der Server gesetzt hat, weil Änderungen auf dem Server jeden Client erreichen.

Was du als Nächstes lernst

Du hast jetzt die Bausteine benutzt, aus denen die meisten Spielskripte bestehen. Eine gute Reihenfolge für das, was als Nächstes kommt (die Guides sind auf Englisch, bis auf den ersten Spiel-Guide):

1. LocalScript vs Script vs ModuleScript: wo jeder Skripttyp läuft und was er ändern kann, tiefer als Schritt 4.
2. RemoteEvents: wie ein LocalScript den Server bittet, etwas zu tun, und wie der Server die Anfrage prüft.
3. Eine Bestenliste: deine ersten Werte, auf dem Server erstellt und geändert.
4. Dein erstes Spiel: ein kurzer Münz-Parcours mit Lava, Coins und einem Ziel-Pad, gesteuert von zwei Server-Skripten, dann veröffentlicht.
5. Dann such dir ein System aus: eine Shop-GUI, ein Rundensystem, Obby-Checkpoints, einen Ladebildschirm oder eine Animation auf Tastendruck. Wenn etwas kaputtgeht, hilft dir der Guide zu Skriptfehlern, die Meldung zu lesen.

Die eigenen Tutorials Coding fundamentals (auf Englisch) von Roblox sind eine gute Ergänzung: sechs Reihen, die von Variablen und Funktionen über Bedingungen, Schleifen sowie Arrays und Dictionaries bis zum Organisieren von Code mit ModuleScripts gehen, mit kleinen Projekten zum Bauen in Studio.

Häufige Fehler und Lösungen

Die meisten Probleme mit ersten Skripten sind ein Name, der nicht passt, ein Skript an der falschen Stelle oder eine Schleife ohne Warten. Lass beim Testen den Output offen.

Mit RoCode weiterkommen

Wenn du bei einem Skript in deinem eigenen Spiel feststeckst, kann RoCode es mit dir lesen. RoCode ist ein unabhängiger KI-Agent für Roblox Studio und stammt nicht von Roblox: Du schreibst in einem Webchat, und sein Studio-Plugin erstellt und bearbeitet die Skripte in deinem Explorer.

Während du lernst, ist der Ask-Modus der nützliche: Du schreibst die Skripte weiterhin selbst, und RoCode liest, was schon da ist, und beantwortet deine Fragen dazu. Prompts kannst du auf Deutsch schreiben.

Im Build-Modus mit Plugin 3.9 oder neuer kann RoCode einen kurzen Playtest machen und die Fehler lesen, und mit Plugin 3.9.11 oder neuer eine Testfigur steuern, um zu prüfen, ob das Spiel funktioniert, aber es macht während des Spiels keine Screenshots, also läufst du trotzdem selbst auf das Pad. Wie sich RoCode mit Studio verbindet.

Häufige Fragen

Quellen und weiterführende Links

• Roblox Creator Docs: Luau (auf Englisch). was Luau ist und woher es kommt
• Roblox Creator Docs: Roblox Studio setup (auf Englisch). Windows und Mac, und die Systemanforderungen
• Roblox Creator Docs: Output (auf Englisch). Output öffnen, Filter, Show Context und Show Source
• Roblox Creator Docs: Studio testing modes (auf Englisch). Play, Run, Stop, der Umschalter Client/Server und Server & Clients
• Roblox Creator Docs: Script Editor (auf Englisch). wo neue Skripte geöffnet werden, und Script Analysis
• Roblox Creator Docs: Script types and locations (auf Englisch). wo jeder Skripttyp läuft, und Parts taggen statt Skripte hineinzulegen
• Roblox Creator Docs: Script (auf Englisch). wann ein Script zu laufen beginnt
• Roblox Creator Docs: Control structures (auf Englisch). if-Abfragen, Schleifen und warum eine Endlosschleife ein Warten braucht
• Roblox Creator Docs: Events (auf Englisch). Connect, und was Touched an deine Funktion übergibt
• Roblox Creator Docs: Debounce patterns (auf Englisch). warum Touched bei einer Berührung mehrmals feuert
• Roblox Creator Docs: wait (auf Englisch). das globale wait() und task.wait()
• Roblox Creator Docs: Network ownership, movement validation and physics exploits (auf Englisch). was ein Client mit seiner eigenen Figur tun kann
• Roblox Creator Docs: Coding fundamentals (auf Englisch). die eigene Anfängerreihe von Roblox

So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 26. Oktober 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.