Ein Roblox-Spiel in Studio erstellen, Schritt für Schritt

Was du baust

Das Spiel ist ein kurzer Parcours. Spieler starten an der SpawnLocation, springen über einem Lavaboden zwischen Plattformen, sammeln Coins und berühren ein grünes Ziel-Pad, das Finish. Das Finish gibt nur einem Spieler einen Win, der seit seinem letzten Spawn oder Ziel mindestens 3 Coins gesammelt hat, und schickt ihn dann zurück zum Start. Coins und Wins erscheinen in der Spielerliste, und jede Regel läuft auf dem Server.

Workspace
  Baseplate Part
  SpawnLocation SpawnLocation
  Course Folder new
    Platform Part new
    Lava Folder new
      Lava Part new
    Coins Folder new
      Coin Part new
    Finish Part new
ServerScriptService
  PlayerStats Script new
  CourseService Script new

Alles in Workspace baust du in Schritt 2 von Hand. Die zwei Skripte kommen in ServerScriptService. Roblox schickt die Skripte in diesem Container nie an Spieler, also kann niemand sie von seinem eigenen Gerät aus lesen oder ändern.

Schritt 1: Studio installieren und eine Baseplate öffnen

1. Lade Roblox Studio aus dem Creator Hub von Roblox herunter und starte das Installationsprogramm (RobloxStudio.exe unter Windows, RobloxStudio.dmg auf dem Mac). Studio ist eine kostenlose App für Windows und Mac.
2. Wenn es sich öffnet, melde dich mit deinem Roblox-Konto an. Hast du keins, leg zuerst eins auf roblox.com an.
3. Wähl im Bereich Open a Template die Vorlage Baseplate. Sie startet mit nur zwei Objekten: einer SpawnLocation, wo Figuren erscheinen und respawnen, und der Baseplate, einem Boden mit einer Rastertextur von 4 mal 4, die auf Studs ausgerichtet ist, die Längeneinheit von Roblox.
4. Öffne drei Fenster, die du ständig brauchst. Explorer listet jedes Objekt in deinem Spiel, und Properties ändert das ausgewählte Objekt; beide öffnest du über das Menü Window oder den Tab Home. Output zeigt Fehler deiner Skripte und öffnet sich über das Menü Window oder den Tab Script.

Schritt 2: Den Parcours bauen

1. Fahr im Explorer mit der Maus über Workspace, klick auf + (oder drück Strg+I, Cmd+I auf dem Mac) und füge einen Folder ein. Nenn ihn Course.
2. Fahr mit der Maus über Course, klick auf + und füge darin zwei weitere Ordner ein. Nenn sie Lava und Coins.
3. Bau den Lavaboden. Klick im Tab Home oder Model auf Part, um einen Block einzufügen, und zieh ihn mit dem Werkzeug Scale zu einer großen, flachen Platte, die unter dem ganzen Parcours liegt, mit viel Platz an jeder Seite. Setz in Properties seine Color auf Rot und sein Material auf Neon, hak Anchored an und zieh ihn in den Ordner Lava. Jetzt landet ein Spieler, der irgendwo herunterfällt, in der Lava und nicht auf der Baseplate.
4. Bau die Plattformen. Füge auf dieselbe Weise weitere Parts ein und setz sie mit den Werkzeugen Move und Scale auf die Lava, jede ein paar Studs darüber, mit Lücken zum Springen dazwischen. Prüf in Properties, dass bei jeder Anchored angehakt ist, und zieh sie in Course.
5. Bau die Coins. Halte den kleinen Pfeil am Button Part gedrückt und wähl Cylinder. Mach ihn klein und gelb, hak Anchored an und nimm den Haken bei CanCollide raus, damit Spieler hindurchlaufen, statt dagegenzustoßen. Leg ihn in den Ordner Coins, drück dann Strg+D (Cmd+D auf dem Mac), um ihn zu duplizieren, bis du mindestens 3 hast, und verteil sie entlang des Parcours über den Plattformen.
6. Bau das Ziel. Füge am anderen Ende noch einen Part auf der Lava ein, groß genug zum Landen, färb ihn grün, hak Anchored an, nenn ihn genau Finish und zieh ihn direkt in Course, nicht in einen der Ordner.
7. Schieb die SpawnLocation an den Anfang des Parcours auf die Lava, neben deine erste Plattform, sodass sie auf der Platte sitzt. Lass sie direkt in Workspace, nicht in Course: CourseService sucht sie dort, um Spieler zurück an den Start zu schicken.

Namen sind wichtig

CourseService findet den Parcours über Namen: einen Ordner namens Course direkt in Workspace, darin die Ordner Lava und Coins und einen Part namens Finish. Schreib sie genau so, mit denselben Großbuchstaben. Die Namen der Lava-Parts und der Coins sind egal: Jeder Part direkt in Lava ist Lava, und jeder Part direkt in Coins ist eine Münze.

Schritt 3: Coins und Wins zur Spielerliste hinzufügen

Fahr im Explorer mit der Maus über ServerScriptService, klick auf +, füge ein Script ein und nenn es PlayerStats. Ersetz alles darin hiermit:

-- Script in ServerScriptService namens PlayerStats.
-- Gibt jedem Spieler die Werte Coins und Wins. Ein Ordner namens leaderstats im
-- Spieler lässt Roblox diese Werte in der Spielerliste oben rechts anzeigen.

local Players = game:GetService("Players")

local function onPlayerAdded(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- muss genau so geschrieben sein

	local coins = Instance.new("IntValue")
	coins.Name = "Coins"
	coins.Value = 0
	coins.Parent = leaderstats

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- alle, die beigetreten sind, bevor diese Zeile lief
	onPlayerAdded(player)
end

Jeder Spieler bekommt einen Ordner namens leaderstats mit zwei IntValue-Objekten darin. Ein IntValue hält eine ganze Zahl, mehr braucht ein Münzzähler nicht. Die Schleife am Ende richtet jeden Spieler ein, der beigetreten ist, bevor die Zeile mit PlayerAdded lief, damit niemand fehlt.

Der Leaderboard-Guide (auf Englisch) baut denselben Ordner ausführlicher und ergänzt später Speichern und eine globale Top 10.

Schritt 4: Lava, Coins und Ziel zum Laufen bringen

Füge ein zweites Script in ServerScriptService ein, nenn es CourseService und füge das hier ein. Es ist der einzige Ort, an dem sich Coins und Wins ändern. Die zwei Einstellungen oben sind die Zahlen, die du ändern sollst.

-- Script in ServerScriptService namens CourseService.
-- Steuert den Parcours auf dem Server, damit jeder Spieler dasselbe sieht und niemand
-- sich selbst Coins geben kann: Lava-Parts setzen Spieler zurück, Coins zahlen 1 Coin und kommen zurück,
-- und das Ziel-Pad Finish gibt Spielern einen Win, die in diesem Lauf genug Coins gesammelt haben.

local Players = game:GetService("Players")

local COINS_TO_FINISH = 3 -- Coins, die ein Spieler in einem Lauf sammeln muss, bevor Finish zählt
local COIN_RESPAWN_SECONDS = 10

local course = workspace:WaitForChild("Course")
local lavaFolder = course:WaitForChild("Lava")
local coinFolder = course:WaitForChild("Coins")
local finish = course:WaitForChild("Finish") :: BasePart
local spawnLocation = workspace:FindFirstChildOfClass("SpawnLocation")
if not spawnLocation then
	warn("CourseService: no SpawnLocation directly in Workspace, so the Finish cannot send players back")
end

-- Coins in diesem Lauf: seit der Spieler zuletzt gespawnt ist oder das Finish erreicht hat
local runCoins: { [Player]: number } = {}

-- Findet den Spieler, dessen Figur einen Part berührt hat, oder nil bei allem anderen
local function playerFromHit(otherPart: BasePart): Player?
	local character = otherPart:FindFirstAncestorOfClass("Model")
	return if character then Players:GetPlayerFromCharacter(character) else nil
end

local function addStat(player: Player, statName: string, amount: number)
	local leaderstats = player:FindFirstChild("leaderstats")
	local stat = leaderstats and leaderstats:FindFirstChild(statName)
	if stat and stat:IsA("IntValue") then
		stat.Value += amount
	end
end

-- Lava: Jeder Part im Ordner Lava setzt den Spieler zurück, der ihn berührt
for _, lava in lavaFolder:GetChildren() do
	if lava:IsA("BasePart") then
		lava.Touched:Connect(function(otherPart: BasePart)
			local character = otherPart:FindFirstAncestorOfClass("Model")
			local humanoid = character and character:FindFirstChildOfClass("Humanoid")
			if humanoid and humanoid.Health > 0 then
				humanoid.Health = 0
			end
		end)
	end
end

-- Coins: Der erste Spieler, der eine Münze berührt, bekommt sie, dann versteckt sie sich bis zum Respawn
for _, coin in coinFolder:GetChildren() do
	if coin:IsA("BasePart") then
		local shownTransparency = coin.Transparency
		local taken = false
		coin.Touched:Connect(function(otherPart: BasePart)
			local player = playerFromHit(otherPart)
			if not player or taken then
				return -- kein Spieler, oder diese Münze wurde schon genommen
			end
			taken = true
			coin.Transparency = 1
			addStat(player, "Coins", 1)
			runCoins[player] = (runCoins[player] or 0) + 1
			task.delay(COIN_RESPAWN_SECONDS, function()
				coin.Transparency = shownTransparency
				taken = false
			end)
		end)
	end
end

-- Finish: ein Win für Spieler, die den Parcours geschafft haben, dann zurück zum Start
finish.Touched:Connect(function(otherPart: BasePart)
	local player = playerFromHit(otherPart)
	if not player or (runCoins[player] or 0) < COINS_TO_FINISH then
		return
	end
	runCoins[player] = 0 -- zuerst setzen, damit erneutes Berühren des Pads nicht doppelt zählt
	addStat(player, "Wins", 1)
	local character = player.Character
	if character and spawnLocation then
		character:PivotTo(spawnLocation.CFrame + Vector3.new(0, 4, 0))
		player:SetAttribute("MovementCheckSkip", true) -- für ein Skript mit Tempoprüfung, falls du eins hinzufügst
	end
end)

-- Eine neue Figur (nach einem Reset oder Sturz) startet einen neuen Lauf
local function onPlayerAdded(player: Player)
	runCoins[player] = 0
	player.CharacterAdded:Connect(function()
		runCoins[player] = 0
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- alle, die beigetreten sind, während dieses Skript auf Course wartete
	onPlayerAdded(player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	runCoins[player] = nil
end)

Die Lava setzt Health auf 0, wie es das Lava-Tutorial von Roblox selbst macht. Eine neue Figur hat nach dem Spawnen an einer SpawnLocation standardmäßig 10 Sekunden lang ein ForceField, und Humanoid:TakeDamage bewirkt nichts, solange eines sie schützt. Health direkt zu setzen ignoriert ForceFields, also funktioniert die Lava auch direkt nach einem Respawn.

Das Finish bewegt die Figur mit character:PivotTo(...), laut der Referenz von Roblox der wichtigste Weg, ein Modell per Skript zu bewegen. Setzt du stattdessen die Position des Root-Parts der Figur, bewegst du nur diesen einen Part vom Rest des Körpers weg.

Die Zeile mit MovementCheckSkip bewirkt allein nichts. Sie ist für die Tempoprüfung auf dem Server im Sprint-Guide (auf Englisch) da: Fügst du diese Prüfung später hinzu, wird der Teleport des Finish nicht als zu schnell markiert.

Warum die Regeln auf dem Server laufen

Jede Regel dieses Parcours liegt mit Absicht in CourseService, einem Server-Script. Würde ein LocalScript die Münze gutschreiben, gäbe es den neuen Coins-Wert nur auf dem Gerät dieses Spielers: Der Server und die anderen Spieler würden ihn nie sehen. Und alles auf dem Gerät eines Spielers lässt sich ändern. Laut dem Sicherheitsguide von Roblox hat ein Exploiter die volle Kontrolle über seinen lokalen Zustand und seinen Netzwerkverkehr, also muss der Server jede wichtige Entscheidung treffen.

Die Münzregel stoppt also den einfachsten Cheat, den Sprung direkt ans Ende, und nicht viel mehr. Für ein erstes Spiel ist das normal. Die nächsten Schichten sind eine Serverprüfung, ob eine Figur wirklich in der Nähe einer Münze oder des Finish ist, bevor es zahlt, so wie der Sicherheitsguide von Roblox die Entfernung eines Spielers zu einem Shop prüft; Checkpoints, die der Reihe nach erreicht werden müssen, wie im Guide zu Obby-Checkpoints; und eine Bewegungsprüfung wie die im Sprint-Guide. Was repliziert wird und was nicht erklärt die Trennung von Client und Server genauer (alle auf Englisch).

Schritt 5: Testen

1. Achte darauf, dass im Dropdown für den Testmodus Test ausgewählt ist, und drück dann auf Play (F5). Dein Name erscheint in der Spielerliste mit Coins 0 und Wins 0.
2. Lauf in eine Münze. Coins geht auf 1, und die Münze verschwindet. Warte 10 Sekunden, und sie kommt zurück. Lauf noch einmal hinein: Coins geht auf 2.
3. Berühr die Lava. Deine Figur geht k.o. und erscheint nach 5 Sekunden, der Standard-Respawnzeit von Roblox, wieder an der SpawnLocation. Coins in der Spielerliste bleibt gleich, aber dein Zähler für diesen Lauf beginnt wieder bei 0.
4. Berühr das Finish mit weniger als 3 Coins in diesem Lauf: Nichts passiert. Sammle 3 Coins und berühr es dann: Wins geht auf 1, und du landest wieder auf der SpawnLocation.
5. Drück auf Stop (Shift+F5). Wähl im Dropdown Server & Clients, stell 2 Clients ein und drück auf Play (oder F7). Nimm in einem Client-Fenster eine Münze und schau ins andere: Die Münze ist dort auch weg, weil der Server sie für alle versteckt hat.

Lass das Output-Fenster die ganze Zeit offen. Diese zwei Skripte geben nichts aus, wenn sie funktionieren, also ist jede Warnung oder jeder rote Fehler von PlayerStats oder CourseService ein echtes Problem. Siehe Häufige Fehler.

Schritt 6: Dein Spiel veröffentlichen

1. Öffne das Menü File und wähl Publish. Das Fenster Game details öffnet sich.
2. Gib einen Name ein, wähl ein Genre (das Subgenre ist optional) und schreib eine kurze Description, was Spieler tun. Hier kannst du auch ein Icon und ein Thumbnail hochladen. Prüf vorher ihre Größen mit dem kostenlosen Größen-Checker für Thumbnails und Icons (auf Englisch).
3. Klick auf Save. Roblox veröffentlicht das Spiel in der Cloud und verbindet es mit deinem Konto, sodass du es auf jedem Computer öffnen kannst.
4. Das Spiel ist jetzt veröffentlicht, aber privat. Nur du, Leute mit Edit-Zugriff und Gruppenmitglieder mit den passenden Rollen können es spielen.
5. Du willst Feedback, bevor du es freigibst? Wähl File > Invite early testers und such bis zu 10 Freunde in ähnlichem Alter aus. Hast du noch keine Altersprüfung gemacht, bittet Roblox dich zuerst darum. Tester sehen ein Wasserzeichen, das ihnen sagt, dass das Spiel eine Vorschau ist.

Ab jetzt speichert Speichern bei Roblox über das Menü File eine Version deines Spiels in der Cloud. File > Publish ist das, was die Version ändert, die Spieler bekommen. Spiel ab und zu die veröffentlichte Kopie über Roblox, außerhalb von Studio, um zu prüfen, ob sie dem entspricht, was du getestet hast.

Schritt 7: Freigeben (dein Spiel öffentlich machen)

Mit dem Freigeben machst du dein Spiel öffentlich, damit auch andere als du und deine Mitwirkenden es spielen können. Prüf vorher die Anforderungen: Dein Konto muss in gutem Zustand und mindestens 2 Tage alt sein, und du brauchst eine Altersprüfung, per Gesichtsalterschätzung oder amtlichem Ausweis.

1. Öffne das Menü File und wähl noch einmal Publish. Das Fenster Publish öffnet sich.
2. Klick auf Continue. (Der Button Invite daneben lädt stattdessen frühe Tester ein.)
3. Beantworte die erste Frage des Maturity & Compliance Questionnaire von Roblox: Enthält dein Spiel altersbeschränkte Inhalte? Antworte für das, was dein Spiel wirklich enthält. Antwortest du mit Yes, füllst du den ganzen Fragebogen aus.
4. Klick auf Publish.

Um nur deine Freunde hineinzulassen, öffne das Creator Dashboard, wähl das Spiel, geh zu Publish settings > Manage Audience, klick auf Manage access, schalte im Tab Public die Option Friends ein und klick auf Save Changes. Mit Friends können nur deine Freunde und die Leute im Tab Playtest spielen.

Dieselben Anforderungen gelten für jede Freigabe: die erste Freigabe, die Freigabe einer neuen Version eines Spiels, das schon draußen ist, die Freigabe in ein anderes Spiel mit Publish As und die Änderung, wer spielen kann.

Mit Freunden bauen

Mit den Zusammenarbeits-Tools von Studio können du und ein Freund dasselbe Spiel gleichzeitig bearbeiten. Für ein Spiel, das dir gehört:

1. Klick mit dem Spiel offen in Studio rechts in der Mezzanine-Leiste, deren linke Seite den Play-Button hat, auf Collaborate.
2. Such deinen Freund, wähl ihn aus, wähl im Berechtigungs-Dropdown Edit und klick auf Save. Bei einem Spiel, das dir gehört, können nur Roblox-Freunde Edit-Zugriff bekommen.
3. Dein Freund öffnet das Spiel über das Creator Dashboard, und ihr arbeitet beide gleichzeitig im selben Spiel.

Um mit anderen Creatorn zusammenzuarbeiten, machst du zuerst eine Altersprüfung, per Ausweis oder Gesichtsalterschätzung. Danach lässt Studio dich standardmäßig nur mit Creatorn in passenden Altersgruppen zusammenarbeiten. Team Create allein kannst du ohne Altersprüfung nutzen. Während einer gemeinsamen Sitzung speichert Studio das Spiel alle vier Minuten in der Cloud.

Ein echtes Spiel daraus machen

Der Parcours ist eine vollständige Schleife: spielen, sammeln, ins Ziel kommen, gewinnen. Jeder dieser Guides (auf Englisch, außer dem ersten) fügt ein System obendrauf.

• Neu bei Skripten? Roblox Scripting für Anfänger erklärt Variablen, Funktionen, Events und Schleifen, die Bausteine von CourseService.
• Coins und Wins speichern zwischen Sitzungen, mit Schritt 3 des Leaderboard-Guides. Sein Speicherskript ersetzt ein Skript für Coins und Wins wie PlayerStats, also lösch PlayerStats, wenn du es hinzufügst. Das DataStore-Tutorial erklärt Speichern ausführlich.
• Checkpoints der Reihe nach, mit einem Wert Stage und Respawn am letzten Checkpoint: der Guide zu Obby-Checkpoints. Sein Skript legt einen eigenen leaderstats-Ordner an, also kopier die Zeilen für Coins und Wins aus PlayerStats in diesen Ordner und lösch PlayerStats. Zwei Skripte, die jeweils leaderstats anlegen, geben jedem Spieler zwei Ordner, und Coins und Wins können aufhören, sich zu ändern.
• Die Coins ausgeben in einer Shop-GUI. Sie nutzt den Coins-Wert in leaderstats, also lass ihr Leaderstats-Skript weg: PlayerStats legt Coins schon an.
• Einen Vorteil gegen Robux verkaufen mit einem Game Pass. Bevor du einen Preis festlegst, zeigt der kostenlose Robux-Steuerrechner, was dir jeder Verkauf nach dem Anteil von Roblox bringt, und der DevEx-Rechner, was diese Robux in US-Dollar wert sind.
• Ein Titelbildschirm mit Play-Button: der Guide zum Hauptmenü. Fertige Bildschirme gibt es auch als Roblox UI-Vorlagen.
• Runden mit Pause, zufälligen Maps und Timer: der Guide zum Rundensystem, der zum selben Wins-Wert hinzufügt. Lass sein leaderstats-Skript weg, weil PlayerStats Wins schon anlegt.
• Eine Intro-Zwischensequenz mit Kameraeinstellungen, Untertiteln und Skip-Button: der Cutscene-Guide.
• Eine Tür zu einem geheimen Bereich, die sich mit E öffnet, mit optionalem Schlüsselschloss: der Tür-Guide.
• Teleporter-Pads zwischen Teilen der Map oder ein Teleport-Menü: der Teleporter-Guide.
• Sprinten mit Shift auf Tastatur, Handy und Gamepad, mit der Bewegungsprüfung auf dem Server: der Sprint-Guide. Seine Bewegungsprüfung liest das Attribut MovementCheckSkip, das das Finish setzt.
• Ein Kampf oder eine andere Schleife: Gib Spielern ein Schwert oder eine Raycast-Waffe, oder starte ein neues Spiel, in dem Spieler für Coins klicken, Upgrades kaufen und rebirthen, mit dem Guide zum Simulator-Spiel.

Häufige Fehler und Lösungen

Öffne das Output-Fenster (Menü Window oder Tab Script), bevor du auf Play drückst. Die meisten Probleme bei diesem Parcours schreiben dort eine Warnung oder einen Fehler, oder sie kommen von einem Namen, der nicht passt.

Mit RoCode bauen

Wenn du das Spiel lieber beschreibst, statt jedes Teil von Hand zu bauen, kann RoCode es in dem Spiel bauen, das du offen hast. RoCode ist ein unabhängiger KI-Agent für Roblox Studio und stammt nicht von Roblox: Du beschreibst das Feature in seinem Webchat, auch auf Deutsch, und sein Studio-Plugin erstellt die Parts und die Skripte in deinem Explorer, also kopierst du keinen Code aus einem Chatfenster.

In Studio bauen ↗

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 prüft nur, was es testen wollte, also spielst du es selbst. Ein ganzes Spiel mit RoCode bauen funktioniert so, ein System pro Prompt. Wie sich RoCode mit Studio verbindet.

Häufige Fragen

Quellen und weiterführende Links

• Roblox Creator Docs: Roblox Studio setup (auf Englisch). Studio ist eine kostenlose App für Windows und Mac; Installieren und Anmelden
• Roblox Creator Docs: Create and publish games and places (auf Englisch). Vorlagen, File > Publish, standardmäßig privat, frühe Tester, öffentliche Freigabe, Anforderungen, das Tageslimit und Manage Audience
• Roblox Creator Docs: Templates (auf Englisch). was die Vorlage Baseplate enthält
• Roblox Creator Docs: Explorer window (auf Englisch). Objekte und Ordner einfügen und duplizieren
• Roblox Creator Docs: Parts (auf Englisch). Parts und Zylinder einfügen, bewegen, skalieren und färben
• Roblox Creator Docs: Deadly lava tutorial (auf Englisch). ein Lava-Part, der beim Berühren Health auf 0 setzt
• Roblox Creator Docs: Create a coin collection mechanic (auf Englisch). Münz-Parts mit CanCollide aus und Anchored an
• Roblox Creator Docs: Score points tutorial (auf Englisch). der Ordner leaderstats und sein genauer Name
• Roblox Creator Docs: BasePart.CanTouch (auf Englisch). Touched mit einem Part mit CanTouch aus zu verbinden wirft einen Fehler
• Roblox Creator Docs: Studio testing modes (auf Englisch). Test, Play (F5), Stop und Server & Clients
• Roblox Creator Docs: Humanoid:TakeDamage (auf Englisch). Schutz durch ForceField, und Health direkt setzen
• Roblox Creator Docs: PVInstance:PivotTo (auf Englisch). der Weg, ein Modell per Skript zu bewegen
• Roblox Creator Docs: Version History (auf Englisch). gespeicherte Versionen und die veröffentlichten Versionen, die Spieler bekommen
• Roblox Creator Docs: Security tactics and cheat mitigation (auf Englisch). dem Client nie vertrauen; Touched-Events auf jede Entfernung
• Roblox Creator Docs: Network ownership, movement validation, and physics (auf Englisch). ein Client kann seine eigene Figur teleportieren und fliegen lassen
• Roblox Creator Docs: Defensive design (auf Englisch). der Obby-Fall mit Teleport ans Ende
• Roblox Creator Docs: Collaboration (auf Englisch). der Button Collaborate, Edit-Zugriff, die Altersprüfung und automatisches Speichern

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.