Tutorial · Spielsysteme

Eine Cutscene in Roblox Studio erstellen

Eine Cutscene in Roblox heißt: Die Kamera übernimmt für ein paar Sekunden, schneidet oder gleitet von Einstellung zu Einstellung, zeigt einen Untertitel und gibt die Kontrolle dann zurück. Dieser Guide baut eine, die du einrichtest, indem du unsichtbare Parts dort platzierst, wo die Kamera sein soll, ganz ohne Plugin. Der Server entscheidet, wann ein Spieler sie sieht (beim ersten Spawn oder wenn er einen Trigger berührt), und das Gerät des Spielers bewegt die Kamera, zeigt schwarze Balken und einen Skip-Button und gibt die Kamera zurück.

Aktualisiert am 14. November 202623 Min. LesezeitGeschrieben von

Kurz gesagt

Platziere unsichtbare, verankerte Parts mit den Namen 1, 2, 3 in einem Ordner in Workspace.Cutscenes, jeder in die Richtung gedreht, in die die Kamera schauen soll. Ein Script in ServerScriptService liest ihre CFrames, hält den Spieler fest und schickt ihm die Einstellungen über ein RemoteEvent. Ein LocalScript in StarterPlayerScripts setzt workspace.CurrentCamera.CameraType auf Scriptable, bewegt die Kamera in jedem Frame von Einstellung zu Einstellung (mit Easing über TweenService:GetValue), setzt CameraType dann wieder auf Custom und CameraSubject auf den Humanoid des Spielers.

  • Nur das Gerät des Spielers kann seine Kamera bewegen, deshalb ist der Kamera-Code ein LocalScript. Der Server entscheidet nur, wer welche Cutscene wann sieht.
  • Ist die Kamera Scriptable, aktualisiert Roblox Camera.Focus nicht mehr. Die Referenz sagt, Focus solle dann in jedem Frame gesetzt werden, sonst wird dynamisches Licht weit weg vom alten Fokus eventuell nicht gerendert.
  • Camera:Interpolate ist veraltet (deprecated). Die Roblox-Referenz sagt, die Kamera stattdessen mit TweenService zu animieren.
Auf dieser Seite
  1. So funktioniert es
  2. 1. Einstellungen platzieren
  3. 2. Server-Skript
  4. 3. LocalScript
  5. 4. Touch-Trigger
  6. Kamera-Details
  7. Ältere Tutorials
  8. Grenzen für Exploits
  9. 5. Testen
  10. Erweitern
  11. Häufige Fehler
  12. Mit RoCode
  13. Häufige Fragen
  14. Quellen und weiterführende Links

So funktioniert eine Cutscene

IllustrationEin Intro mit zwei Einstellungen in Echtzeit: ein Schnitt auf die erste Einstellung, 1 Sekunde Halten, 2,5 Sekunden Fahrt zur Brücke, 1 Sekunde Halten, dann geht die Kamera an den Spieler zurück.

Jedes Gerät eines Spielers hat sein eigenes Camera-Objekt unter workspace.CurrentCamera, also kann nur ein LocalScript bewegen, was dieser Spieler sieht (auf Englisch). Zu entscheiden, wer welche Cutscene wann sieht, ist Aufgabe des Servers. Dieser Guide teilt die Arbeit genau so auf. Eine Cutscene läuft so ab:

  1. Der Server entscheidet, dass ein Spieler eine Cutscene sehen soll: das Intro bei seinem ersten Spawn auf dem Server, oder eine andere, wenn er einen Trigger-Part berührt.
  2. CutsceneService liest die CFrames und Einstellungen der Kamera-Parts, bittet Roblox, den Bereich der ersten Einstellung zu diesem Spieler zu streamen, verankert den HumanoidRootPart des Spielers, damit er stehen bleibt, und feuert CutsceneEvent nur an diesen Spieler, mit einer ID und der Liste der Einstellungen.
  3. CutscenePlayer zeigt auf dem Gerät dieses Spielers die schwarzen Balken und den Skip-Button, blendet Spielerliste, Backpack, Lebensanzeige und Touch-Steuerung aus, macht die Kamera Scriptable und bewegt sie in jedem Frame.
  4. Wenn die letzte Einstellung endet oder der Spieler auf Skip drückt, gibt es die Kamera an den Charakter zurück und feuert CutsceneEvent mit derselben ID an den Server.
  5. Der Server löst die Verankerung des Spielers. Kommt diese Nachricht nie an, löst er sie trotzdem, sobald die Länge der Cutscene plus 2 Sekunden vergangen ist. Dieser Timer startet, wenn der Server die Cutscene schickt, und bei einem langsamen Beitritt kann das Gerät das Intro ein paar Sekunden später starten, weil LocalScripts außerhalb von ReplicatedFirst erst laufen, wenn das Spiel geladen ist. Dann kann sich der Spieler wieder bewegen, bevor das Intro auf seinem Bildschirm zu Ende ist.
Die Teile des Cutscene-Systems
TeilWo es liegtWas es tut
Das Script CutsceneServiceServerScriptServiceEntscheidet, wer welche Cutscene wann sieht, liest die Einstellungen, hält den Spieler fest und merkt sich, wer was gesehen hat.
Das LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsSpielt eine Cutscene auf dem Bildschirm des Spielers ab: Balken, Untertitel, Skip und die Kamerafahrten. Gibt die Kamera am Ende zurück.
Das RemoteEvent CutsceneEventReplicatedStorage (CutsceneService erstellt es)Bringt die Einstellungen vom Server zu einem Spieler und die Nachricht "Cutscene zu Ende" zurück.
Der Ordner CutscenesWorkspaceEin Ordner pro Cutscene, etwa Intro, mit den Kamera-Parts 1, 2, 3.
Der Ordner CutsceneTriggersWorkspace (optional)Parts, die eine Cutscene starten, wenn ein Spieler sie berührt.
Der Explorer, wenn das Cutscene-System fertig ist. Der Ordner Bridge und CutsceneTriggers kommen in Schritt 4. CutsceneService fügt ReplicatedStorage beim Spielstart ein RemoteEvent namens CutsceneEvent hinzu.
Workspace
  Cutscenes Folder new
    Intro Folder new
      1 Part new
      2 Part new
      3 Part new
    Bridge Folder new
      1 Part new
      2 Part new
  CutsceneTriggers Folder new
    BridgeTrigger Part new
ServerScriptService
  CutsceneService Script new
StarterPlayer
  StarterPlayerScripts
    CutscenePlayer LocalScript new

Schritt 1: Die Kameraeinstellungen platzieren

Jede Einstellung ist ein unsichtbarer Part. Die Kamera übernimmt die Position des Parts und schaut in dieselbe Richtung wie seine Vorderseite. Eine Einstellung zu platzieren heißt also, die Kamera zu platzieren.

  1. Fahr im Explorer mit der Maus über Workspace, klick auf + und füge einen Folder namens Cutscenes ein. Füge darin einen Folder namens Intro ein. Bei Namen zählt Groß- und Kleinschreibung.
  2. Flieg mit der Studio-Kamera zur ersten Ansicht, die du willst, als würdest du ein Foto einrahmen.
  3. Füge einen Part in Intro ein und benenne ihn in 1 um.
  4. Öffne die Command Bar (im Tab Script, oder über Window, dann Script) und führe workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame aus. Im Bearbeitungsmodus ist CurrentCamera die Ansicht, durch die du gerade schaust, also springt der Part genau auf diese Einstellung. Die eckigen Klammern und Anführungszeichen braucht es, weil ein Name, der mit einer Ziffer beginnt, nicht nach einem Punkt stehen kann.
  5. Hak in den Properties des Parts Anchored an, nimm die Haken bei CanCollide, CanTouch und CanQuery raus und setz Transparency auf 1. Anchored verhindert, dass er durch die Map fällt; die anderen verhindern, dass er Spieler blockiert, Touch-Events auslöst und Raycasts im Weg ist.
  6. Wiederhole das für die nächsten Ansichten, nenn die Parts 2, 3 und so weiter und ändere die Zahl in der Command-Bar-Zeile passend. CutsceneService spielt die Einstellungen in Zahlenreihenfolge ab und stoppt bei der ersten fehlenden Zahl, also beendet eine Lücke die Cutscene zu früh.

Um eine Einstellung später zu ändern, flieg mit der Kamera zur neuen Ansicht und führe dieselbe Zeile mit der Nummer dieser Einstellung aus. Mit Transparency 1 sind die Parts auch in Studio unsichtbar, also wähl sie im Explorer aus, wenn du sie brauchst.

Jede Einstellung kann außerdem drei optionale Attribute haben. Um eins hinzuzufügen, wähl den Part aus, scroll zum Abschnitt Attributes im Properties-Fenster, klick auf +, gib den Namen ein, wähl den Typ und klick auf Save.

Optionale Attribute an jedem Kamera-Part
AttributTypStandardWas es tut
MoveSecondsnumber3Sekunden, die die Kamera braucht, um von der vorigen Einstellung zu dieser zu gleiten. 0 macht daraus einen Schnitt. Einstellung 1 ist immer ein Schnitt und ignoriert das deshalb.
HoldSecondsnumber1Sekunden, die die Kamera nach der Ankunft auf dieser Einstellung bleibt.
CaptionstringkeinerText im unteren Balken, ab dem Moment, in dem die Kamera zu dieser Einstellung losfährt. Eine Einstellung ohne Caption leert den Text.

Eine Zahl unter 0 oder über 60, oder ein Attribut mit falschem Typ, fällt auf den Standardwert zurück.

Schritt 2: Das Server-Skript hinzufügen

Fahr mit der Maus über ServerScriptService, füge ein Script namens CutsceneService ein und füge den Code unten ein. Die Einstellungen oben sind die Zeilen, die du ändern sollst.

Script in ServerScriptService namens CutsceneService
-- Script in ServerScriptService namens CutsceneService.
-- Entscheidet, wer welche Cutscene wann sieht. Es liest die Kameraeinstellungen aus nummerierten
-- Parts in Workspace.Cutscenes, hält den Spieler fest und sagt dem Gerät dieses Spielers,
-- dass es die Einstellungen abspielen soll. Die Kamera selbst lässt sich nur auf dem Gerät bewegen.

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

-- Einstellungen
local INTRO_CUTSCENE = "Intro" -- läuft einmal, wenn ein Spieler zum ersten Mal spawnt; "" für keins
local DEFAULT_MOVE_SECONDS = 3 -- Fahrzeit zu einer Einstellung ohne MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- Haltezeit auf einer Einstellung ohne HoldSeconds
local MAX_SHOTS = 30

local cutscenes = workspace:WaitForChild("Cutscenes")
local triggers = workspace:FindFirstChild("CutsceneTriggers")

-- Dieses Skript erstellt CutsceneEvent selbst, also füge keins von Hand hinzu
local cutsceneEvent = Instance.new("RemoteEvent")
cutsceneEvent.Name = "CutsceneEvent"
cutsceneEvent.Parent = ReplicatedStorage

type Shot = { cframe: CFrame, move: number, hold: number, caption: string }

local seen: { [Player]: { [string]: boolean } } = {}
local playing: { [Player]: number } = {} -- die ID der Cutscene, die ein Spieler gerade anschaut
local lastId = 0

local function secondsAttribute(part: Instance, name: string, default: number): number
	local value = part:GetAttribute(name)
	if typeof(value) == "number" and value >= 0 and value <= 60 then
		return value
	end
	return default
end

-- Einstellungen sind Parts namens 1, 2, 3 ... in einem Ordner, der wie die Cutscene heißt
local function readShots(name: string): { Shot }
	local shots: { Shot } = {}
	local folder = cutscenes:FindFirstChild(name)
	if not folder then
		warn(`CutsceneService: no folder named {name} in Workspace.Cutscenes`)
		return shots
	end
	for index = 1, MAX_SHOTS do
		local part = folder:FindFirstChild(tostring(index))
		if not (part and part:IsA("BasePart")) then
			break
		end
		local caption = part:GetAttribute("Caption")
		table.insert(shots, {
			cframe = part.CFrame,
			-- die erste Einstellung ist ein Schnitt, also springt die Kamera direkt dorthin
			move = if index == 1 then 0 else secondsAttribute(part, "MoveSeconds", DEFAULT_MOVE_SECONDS),
			hold = secondsAttribute(part, "HoldSeconds", DEFAULT_HOLD_SECONDS),
			caption = if typeof(caption) == "string" then caption else "",
		})
	end
	return shots
end

local function setFrozen(player: Player, frozen: boolean)
	local character = player.Character
	local rootPart = character and character:FindFirstChild("HumanoidRootPart")
	if rootPart and rootPart:IsA("BasePart") then
		rootPart.Anchored = frozen
	end
end

local function finish(player: Player, id: number)
	if playing[player] ~= id then
		return -- diese Cutscene ist schon zu Ende
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- eine Cutscene auf einmal
	end
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then
		return false
	end
	local shots = readShots(name)
	if #shots == 0 then
		return false
	end

	lastId += 1
	local id = lastId
	playing[player] = id

	-- Mit Instance Streaming an hat das Gerät des Spielers den Bereich, auf den eine Einstellung
	-- schaut, eventuell nicht, und eine Anfrage lädt einen Bereich nur eine Weile. Lade den Bereich
	-- der ersten Einstellung jetzt (bis zu 2 Sekunden Wartezeit) und den jeder späteren 2 Sekunden,
	-- bevor die Kamera dorthin losfährt.
	local function request(position: Vector3)
		pcall(function()
			player:RequestStreamAroundAsync(position, 2)
		end)
	end
	request(shots[1].cframe.Position)
	if playing[player] ~= id or player.Parent ~= Players then
		return false -- der Spieler ist gegangen, während der Bereich geladen hat
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- Sekunden ab jetzt, bis die Kamera zu dieser Einstellung losfährt
	for index, shot in shots do
		if index > 1 then
			task.delay(math.max(startsAt - 2, 0), function()
				if playing[player] == id then
					request(shot.cframe.Position)
				end
			end)
		end
		startsAt += shot.move + shot.hold
	end
	-- Sicherheitsnetz: den Spieler freigeben, auch wenn sich sein Gerät nie zurückmeldet
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Gibt nur true zurück, wenn die Cutscene für diesen Spieler gestartet ist
local function playOnce(player: Player, name: string): boolean
	local playerSeen = seen[player]
	if not playerSeen or playerSeen[name] then
		return false
	end
	if play(player, name) then
		playerSeen[name] = true
		return true
	end
	return false
end

-- Das Gerät des Spielers meldet, dass die Cutscene zu Ende ist oder übersprungen wurde
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Trigger-Parts: wer einen berührt, sieht die Cutscene aus seinem Attribut Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Touched an einem Part mit CanTouch aus zu verbinden wirft einen Fehler, also stattdessen warnen
			warn(`CutsceneService: tick CanTouch on {trigger:GetFullName()} so it can start a cutscene`)
			continue
		end
		trigger.Touched:Connect(function(otherPart: BasePart)
			local name = trigger:GetAttribute("Cutscene")
			local character = otherPart:FindFirstAncestorOfClass("Model")
			local player = character and Players:GetPlayerFromCharacter(character)
			if player and typeof(name) == "string" then
				playOnce(player, name)
			end
		end)
	end
end

local function onCharacterAdded(player: Player, character: Model)
	character:WaitForChild("HumanoidRootPart", 10)
	if playing[player] then
		setFrozen(player, true) -- während einer Cutscene respawnt, also auch den neuen Charakter festhalten
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- schon eingerichtet
	end
	seen[player] = {}
	player.CharacterAdded:Connect(function(character: Model)
		onCharacterAdded(player, character)
	end)
	local character = player.Character
	if character then
		task.spawn(onCharacterAdded, player, character)
	end
end

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

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

CutsceneService erstellt das RemoteEvent CutsceneEvent selbst, sobald Workspace.Cutscenes existiert, also musst du in ReplicatedStorage nichts von Hand einfügen. Wenn du schon ein RemoteEvent mit diesem Namen erstellt hast, lösch es: Das LocalScript könnte deins finden, und auf das hört auf dem Server niemand.

Die Einstellungen oben in CutsceneService
EinstellungWert hierWas sie ändert
INTRO_CUTSCENE"Intro"Der Ordner in Workspace.Cutscenes, der abgespielt wird, wenn ein Spieler zum ersten Mal auf einem Server spawnt. Setz ihn auf "" für kein Intro.
DEFAULT_MOVE_SECONDS3Wie lange eine Fahrt dauert, wenn eine Einstellung kein MoveSeconds-Attribut hat.
DEFAULT_HOLD_SECONDS1Wie lange die Kamera auf einer Einstellung bleibt, wenn sie kein HoldSeconds-Attribut hat.
MAX_SHOTS30Die höchste Einstellungsnummer, nach der CutsceneService in einer Cutscene sucht.

Was der Rest des Skripts tut, der Reihe nach:

  • Liest die Einstellungen auf dem Server. readShots sammelt CFrame und Attribute jedes nummerierten Parts in einer Liste. Das Gerät des Spielers bekommt diese Liste und braucht die Parts selbst also nie.
  • Eine Cutscene auf einmal. play tut nichts, solange der Spieler schon eine anschaut, oder wenn sein Charakter keinen Humanoid hat oder tot ist.
  • Eine ID für jede Cutscene. Das Gerät schickt die ID zurück, wenn die Cutscene endet oder übersprungen wird, und nur die passende ID gibt den Spieler frei, also kann eine verspätete Nachricht von einer früheren Cutscene keine neuere beenden.
  • Hält den Spieler fest, indem es seinen HumanoidRootPart verankert, und verankert auch den neuen Charakter, wenn der Spieler mitten in der Cutscene respawnt. Laut der Roblox-Referenz ändert ein verankerter Part seine Position nie durch Schwerkraft, Kollisionen oder andere Physik. WalkSpeed bleibt unangetastet, also kommt sich das nicht mit einem Sprint-Skript oder einem Speed-Pass in die Quere. Am Ende löst es die Verankerung des Root-Parts, auch wenn ein anderes Skript ihn verankert hat, also verankere Charaktere nicht anderswo, solange eine Cutscene laufen kann.
  • Ein Sicherheitsnetz. task.delay gibt den Spieler nach der Gesamtlänge der Cutscene plus 2 Sekunden frei, auch wenn sich sein Gerät nie zurückmeldet.
  • Spielt jede Cutscene einmal pro Server ab. Die Tabelle seen merkt sich für jeden Spieler, welche Cutscenes gestartet sind, damit das Intro beim Respawn nicht erneut läuft und eine Trigger-Cutscene einmal abgespielt wird. playOnce gibt nur true zurück, wenn die Cutscene wirklich gestartet ist.
  • Richtet jeden Spieler ein. Die Schleife über Players:GetPlayers() am Ende erfasst alle, die beigetreten sind, während das Skript auf den Ordner Cutscenes gewartet hat.

Die Einstellungen gehen in einem einzigen FireClient-Aufruf an den Spieler, als Liste kleiner Tabellen. Die Roblox-Seite zu Remote Events sagt, man solle keine Tabelle schicken, die Zahlen- und String-Schlüssel mischt; diese Liste hat nur Zahlenschlüssel, und jede Einstellung darin hat nur String-Schlüssel, genau die Form, die dort verlangt wird.

Schritt 3: Das LocalScript hinzufügen, das sie abspielt

  1. Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts und füge ein LocalScript namens CutscenePlayer ein.
  2. Ersetze seinen Inhalt durch den Code unten.
LocalScript in StarterPlayerScripts namens CutscenePlayer
-- LocalScript in StarterPlayer > StarterPlayerScripts namens CutscenePlayer.
-- Spielt eine Cutscene ab, die der Server schickt: schwarze Balken, Untertitel, ein Skip-Button und die
-- Kamera, die von Einstellung zu Einstellung gleitet. Dann gibt es die Kamera an den Spieler zurück.

local GuiService = game:GetService("GuiService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local StarterGui = game:GetService("StarterGui")
local TweenService = game:GetService("TweenService")
local UserInputService = game:GetService("UserInputService")

local cutsceneEvent = ReplicatedStorage:WaitForChild("CutsceneEvent") :: RemoteEvent
local player = Players.LocalPlayer
local camera = workspace.CurrentCamera

local BAR_HEIGHT = 0.12 -- jeder schwarze Balken, als Anteil der Bildschirmhöhe
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- Studs vor der Kamera, die Roblox am detailliertesten rendern soll
local HIDDEN_CORE_GUIS = { Enum.CoreGuiType.PlayerList, Enum.CoreGuiType.Backpack, Enum.CoreGuiType.Health }
local REGULAR = Font.fromEnum(Enum.Font.BuilderSans)
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)

type Shot = { cframe: CFrame, move: number, hold: number, caption: string }

-- Der Cutscene-Bildschirm: zwei schwarze Balken und ein Untertitel, von Rand zu Rand. Laut Roblox ist
-- ScreenInsets None nur für Dinge, auf die niemand drückt, also bekommt Skip unten ein eigenes ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- den ganzen Bildschirm abdecken
gui.DisplayOrder = 10
gui.Enabled = false

local topBar = Instance.new("Frame")
topBar.Size = UDim2.fromScale(1, BAR_HEIGHT)
topBar.BackgroundColor3 = Color3.new(0, 0, 0)
topBar.BorderSizePixel = 0
topBar.Parent = gui

local bottomBar = topBar:Clone()
bottomBar.Position = UDim2.fromScale(0, 1 - BAR_HEIGHT)
bottomBar.Parent = gui

local caption = Instance.new("TextLabel")
caption.Size = UDim2.fromScale(0.7, 0.5)
caption.Position = UDim2.fromScale(0.15, 0.25)
caption.BackgroundTransparency = 1
caption.TextColor3 = Color3.new(1, 1, 1)
caption.TextScaled = true
caption.FontFace = REGULAR
caption.Text = ""
caption.Parent = bottomBar

-- Der Skip-Button behält die Standard-Insets, damit er nicht unter Kamera-Notches liegt
local controls = Instance.new("ScreenGui")
controls.Name = "CutsceneControls"
controls.ResetOnSpawn = false
controls.DisplayOrder = 11
controls.Enabled = false

local skipButton = Instance.new("TextButton")
skipButton.AnchorPoint = Vector2.new(1, 0.5)
skipButton.Size = UDim2.fromScale(0.1, BAR_HEIGHT * 0.5)
skipButton.Position = UDim2.new(1, -16, 1 - BAR_HEIGHT / 2, 0) -- auf dem unteren Balken, rechts
skipButton.BackgroundColor3 = Color3.fromRGB(60, 60, 60)
skipButton.TextColor3 = Color3.new(1, 1, 1)
skipButton.TextScaled = true
skipButton.FontFace = BOLD
skipButton.Text = "Skip"
skipButton.Parent = controls

-- Skip groß genug halten, um ihn auf einem kleinen Handybildschirm anzutippen
local skipMinSize = Instance.new("UISizeConstraint")
skipMinSize.MinSize = Vector2.new(64, 32)
skipMinSize.Parent = skipButton

local playerGui = player:WaitForChild("PlayerGui")
gui.Parent = playerGui
controls.Parent = playerGui

-- Die aktuelle Fahrt: von einem Kamera-CFrame zum nächsten über eine Anzahl Sekunden
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Läuft in jedem Frame einer Cutscene. Der Focus einer Scriptable-Kamera folgt
-- nichts von selbst, also wird er hier auch gesetzt.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- etwas hat sie zurückgesetzt, etwa ein Respawn
	end
	local alpha = if moveSeconds > 0 then (os.clock() - moveStart) / moveSeconds else 1
	local eased = TweenService:GetValue(alpha, EASING_STYLE, Enum.EasingDirection.InOut)
	camera.CFrame = moveFrom:Lerp(moveTo, eased)
	camera.Focus = camera.CFrame * CFrame.new(0, 0, -FOCUS_DISTANCE)
end

local function waitOrSkip(seconds: number)
	local endTime = os.clock() + seconds
	while os.clock() < endTime and not skipRequested do
		task.wait()
	end
end

local function play(id: number, shots: { Shot })
	if busy then
		-- Es läuft schon eine, also den Server den Spieler für diese hier sofort freigeben lassen
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Spielerliste, Backpack und Lebensanzeige ausblenden und merken, was sichtbar war
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- Auf Handys Thumbstick und Sprung-Button ausblenden, die in den unteren Ecken sitzen
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- Ein Controller kann nur einen ausgewählten Button drücken, also Skip für Gamepad-Spieler auswählen
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Eine Stufe nach dem eigenen Kamera-Update von Roblox, wie im Kamera-Tutorial von Roblox
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- jede Fahrt dort beginnen, wo die Kamera gerade ist
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- Die Kamera an den Charakter des Spielers zurückgeben
	RunService:UnbindFromRenderStep("Cutscene")
	camera.CameraType = Enum.CameraType.Custom
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid then
		camera.CameraSubject = humanoid
	end
	if GuiService.SelectedObject == skipButton then
		GuiService.SelectedObject = nil
	end
	gui.Enabled = false
	controls.Enabled = false
	caption.Text = ""
	-- Nur die wieder einschalten, die diese Cutscene ausgeschaltet hat, den Rest in Ruhe lassen
	for coreGui, enabled in wasEnabled do
		if enabled then
			StarterGui:SetCoreGuiEnabled(coreGui, true)
		end
	end
	if touchControlsWere then
		GuiService.TouchControlsEnabled = true
	end
	cutsceneEvent:FireServer(id) -- lässt den Server den Spieler jetzt freigeben
	busy = false
end

skipButton.Activated:Connect(function()
	skipRequested = true
end)

cutsceneEvent.OnClientEvent:Connect(function(id: number, shots: { Shot })
	play(id, shots)
end)

Ein LocalScript in StarterPlayerScripts wird einmal zum Spieler kopiert, wenn er beitritt, und läuft weiter, wenn sein Charakter respawnt. Deshalb haben beide ScreenGuis ResetOnSpawn aus: Wäre es an, würde Roblox sie beim ersten Respawn löschen, und dieses Skript würde sie nicht neu erstellen. Remote-Nachrichten, die ankommen, bevor sich das Skript mit OnClientEvent verbindet, werden gepuffert und zugestellt, sobald es das tut, also sieht auch ein Spieler, der schnell spawnt, das Intro.

Was jeder Teil von CutscenePlayer tut
TeilWas er tut
Das ScreenGui CutsceneZwei schwarze Balken, jeder 12 % der Bildschirmhöhe (BAR_HEIGHT), mit dem Untertitel im unteren Balken. ScreenInsets None lässt die Balken bis an die Bildschirmränder reichen, und DisplayOrder 10 zeichnet sie über ScreenGuis mit niedrigerer DisplayOrder.
Das ScreenGui CutsceneControlsEnthält nur den Skip-Button rechts auf dem unteren Balken, mit einem UISizeConstraint, der ihn mindestens 64 mal 32 Pixel groß hält, damit er sich am Handy gut antippen lässt. Es behält die Standard-ScreenInsets, die seinen Inhalt von den Buttons der Roblox-Topbar und von Kamera-Notches fernhalten. Roblox sagt, None nur für Inhalte zu nutzen, auf die man nicht drückt, also kann Skip nicht im ScreenGui der Balken liegen.
HIDDEN_CORE_GUISBlendet Spielerliste, Backpack und Lebensanzeige mit SetCoreGuiEnabled aus, nachdem es mit GetCoreGuiEnabled notiert hat, welche davon an waren, und schaltet am Ende nur die wieder ein, die es selbst ausgeschaltet hat. Ein Spiel, das den Backpack anderswo ausblendet, behält ihn ausgeblendet, und ein Skript, das sie während der Cutscene einschaltet, etwa ein Hauptmenü, bleibt unberührt.
TouchControlsEnabledAuf Handys und Tablets setzt play GuiService.TouchControlsEnabled für die Cutscene auf false. Das blendet Thumbstick und Sprung-Button aus, die in den unteren Ecken sitzen, wo auch Skip ist, und sie kommen am Ende zurück, wenn sie an waren.
updateCameraLäuft in jedem Frame, solange eine Cutscene spielt. Es berechnet, wie weit die aktuelle Fahrt ist, wendet darauf Easing mit TweenService:GetValue an, platziert die Kamera mit CFrame:Lerp zwischen den zwei Einstellungen und setzt Focus 30 Studs vor die Kamera.
waitOrSkipWartet die Fahr- und Haltezeit einer Einstellung ab und prüft dabei in jedem Frame das Skip-Flag.
playMacht die Kamera Scriptable, spielt die Einstellungen der Reihe nach ab, gibt dann die Kamera zurück (CameraType Custom, CameraSubject der Humanoid), schaltet Core-GUIs und Touch-Steuerung wieder ein und feuert die ID der Cutscene an den Server. Kommt eine zweite Cutscene an, während noch eine läuft, schickt es deren ID sofort zurück, damit der Server den Spieler nicht für eine Cutscene festhält, die dieses Gerät nicht gezeigt hat.
Der Skip-ButtonActivated feuert bei einem Mausklick, einem Antippen oder der A-Taste eines Controllers, sobald der Button ausgewählt ist. Für einen Spieler, dessen bevorzugte Eingabe ein Gamepad ist, wählt play Skip beim Start der Cutscene aus und hebt die Auswahl am Ende auf.

Ändere BAR_HEIGHT, um die Balken dünner oder dicker zu machen, und EASING_STYLE, um zu ändern, wie sich die Fahrten anfühlen (siehe Was der Kamera-Code richtig macht). Untertitel und Skip-Button nutzen TextScaled, also wächst und schrumpft ihr Text mit dem Bildschirm.

Schritt 4: Eine Cutscene abspielen, wenn ein Spieler einen Part berührt

Das Intro läuft von selbst. Für eine Cutscene an einem Ort in deiner Map, etwa wenn ein Spieler zum ersten Mal eine Brücke erreicht, fügst du eine zweite Cutscene und einen Trigger-Part hinzu.

  1. Füge in Workspace, Cutscenes einen Folder namens Bridge ein und platziere seine Einstellungen wie in Schritt 1, mit den Namen 1 und 2. Nimm in der Command-Bar-Zeile Bridge statt Intro.
  2. Fahr mit der Maus über Workspace und füge einen Folder namens CutsceneTriggers ein.
  3. Füge darin einen Part namens BridgeTrigger ein. Mach ihn so groß, dass Spieler nicht vorbeilaufen können, ohne ihn zu berühren, zum Beispiel eine hohe, breite Platte quer über den Weg. Hak Anchored an, nimm die Haken bei CanCollide und CanQuery raus, lass CanTouch angehakt und setz Transparency auf 1. CanQuery aus verhindert, dass die unsichtbare Platte Raycasts blockiert, etwa die Schüsse aus dem Waffen-Guide (auf Englisch). Touch-Events steuert CanTouch, nicht CanQuery, also funktioniert der Trigger weiter.
  4. Gib ihm ein Attribut namens Cutscene vom Typ string und setz den Wert auf Bridge: den Namen des Ordners, der abgespielt werden soll.

CutsceneService verbindet Touched beim Serverstart mit jedem Part direkt in CutsceneTriggers, also füge Trigger in Studio hinzu, nicht per Skript während das Spiel läuft. Ein Trigger mit CanTouch aus wird mit einer Warnung im Output übersprungen, weil Roblox einen Fehler wirft, wenn ein Skript Touched an so einem Part verbindet.

Touched feuert viele Male kurz hintereinander, während ein Charakter durch einen Part läuft. Die Tabelle seen und die Regel "eine Cutscene auf einmal" machen daraus eine Cutscene pro Spieler pro Server. Ein Spieler, der den Trigger berührt, während eine andere Cutscene läuft, wird ignoriert, und der Trigger bleibt für ihn bereit.

Halt Trigger von Straßen fern. Der HumanoidRootPart eines sitzenden Spielers ist mit dem Sitz verschweißt, und wenn ein Part einer verschweißten Gruppe verankert wird, verankert Roblox den Rest mit. Ein Spieler, der in einen Trigger fährt, hält also sein ganzes Fahrzeug fest, Mitfahrer eingeschlossen, bis die Cutscene endet.

Was der Kamera-Code richtig macht

Scriptable, dann zurück auf Custom

Die Kamera-Skripte von Roblox bewegen und aktualisieren die Kamera nicht, solange CameraType Scriptable ist, und genau das lässt CutscenePlayer sie platzieren. Am Ende setzt es CameraType zurück auf Custom und macht den Humanoid des Spielers zum CameraSubject, dem die Kamera-Skripte von Roblox standardmäßig folgen. Das läuft auch nach einem Skip, also schaut der Spieler nie hängend auf die letzte Einstellung.

Zwei kleine Sicherungen halten die Cutscene am Steuer, solange sie läuft. Setzt irgendetwas CameraType mitten in der Cutscene auf etwas anderes, setzt die Funktion pro Frame es im nächsten Frame wieder auf Scriptable. Und das Skript liest workspace.CurrentCamera am Anfang jeder Cutscene neu, weil Roblox eine neue Camera erstellt, falls die aktuelle je zerstört wird.

Focus, in jedem Frame

Camera.Focus sagt der Engine, welchen Bereich sie bei Arbeit wie der Beleuchtung bevorzugen soll. Die Kamera-Skripte von Roblox halten ihn auf dem CameraSubject, aber nicht, solange die Kamera Scriptable ist, und die Roblox-Referenz sagt, ihn in diesem Fall in jedem Frame zu aktualisieren: Dynamisches Licht von Objekten wie PointLights wird weit weg vom Fokus eventuell nicht gerendert. CutscenePlayer setzt ihn 30 Studs vor die Kamera (FOCUS_DISTANCE). Erhöh den Wert, wenn deine Einstellungen auf etwas weiter Entferntes schauen.

Die Funktion läuft über RunService:BindToRenderStep, in jedem Frame bevor er gezeichnet wird, eine Prioritätsstufe nach dem eigenen Kamera-Update von Roblox (Enum.RenderPriority.Camera.Value + 1). Das ist die Priorität aus dem Kamera-Tutorial von Roblox, also platziert die Cutscene die Kamera, nachdem der eigene Kamera-Code von Roblox gelaufen ist.

Easing mit TweenService:GetValue

Ein Tween auf camera.CFrame würde die Kamera bewegen, aber der Focus muss trotzdem in jedem Frame gesetzt werden, also übernimmt CutscenePlayer die Bewegung selbst in derselben Funktion. Für jede Fahrt berechnet es den vergangenen Anteil der Fahrzeit (von 0 bis 1), gibt ihn mit einem Easing-Stil und einer Richtung durch TweenService:GetValue und platziert die Kamera so weit zwischen den zwei Einstellungen mit CFrame:Lerp, das die Position auf einer geraden Linie bewegt und die Drehung weich mitdreht. GetValue begrenzt seine Eingabe auf 0 bis 1, also hält die Kamera genau auf der Einstellung, wenn die Fahrzeit abgelaufen ist.

Easing-Stile, die zu einer Kamerafahrt passen
EASING_STYLEWie sich die Fahrt anfühlt
Enum.EasingStyle.Sine (hier genutzt)Die Geschwindigkeit folgt einer Sinuskurve, für einen sanften Start und Stopp.
Enum.EasingStyle.QuadWie Sine, mit einer etwas schärferen Kurve.
Enum.EasingStyle.LinearKonstante Geschwindigkeit, also startet und stoppt jede Fahrt mit voller Geschwindigkeit.

Die Richtung ist InOut: Das Easing wird in der ersten Hälfte der Fahrt vorwärts und in der zweiten Hälfte umgekehrt angewendet, also beschleunigt die Kamera aus einer Einstellung heraus und bremst in die nächste hinein.

Streaming

Neue Places haben Instance Streaming an: Standardmäßig hat das Gerät eines Spielers den Bereich um seinen Charakter, also kann eine Einstellung, die auf die andere Seite der Map schaut, eine leere Welt zeigen. CutsceneService bittet Roblox mit Player:RequestStreamAroundAsync, den Bereich jeder Einstellung zu diesem Spieler zu streamen: den Bereich der ersten Einstellung, bevor es das Event feuert, mit bis zu 2 Sekunden Wartezeit, und den Bereich jeder späteren Einstellung 2 Sekunden bevor die Kamera dorthin losfährt.

Roblox sagt, dass der Bereich dadurch wahrscheinlich, aber nicht sicher geladen ist, und dass der Effekt nur vorübergehend ist. Halt wichtige Einstellungen innerhalb deines Streaming-Radius, oder nutze auf dem Server Player:AddReplicationFocus für einen Bereich, der geladen bleiben muss, bis du den Fokus entfernst. Mit Streaming aus hat das Gerät sowieso die ganze Map, und das pcall um jede Anfrage sorgt dafür, dass eine fehlgeschlagene Anfrage die Cutscene nicht stoppen kann.

Was ältere Cutscene-Tutorials falsch machen

Wenn du diesen Guide mit einem Video oder einem Forenbeitrag vergleichst, sind das die Unterschiede, die zählen, jeweils mit dem Grund, warum das Muster ein Problem ist.

Häufige Muster in Cutscene-Tutorials und was dieser Guide stattdessen macht
Das TutorialDas ProblemDieser Guide
Bewegt die Kamera mit camera:Interpolate()Roblox markiert Interpolate als veraltet und sagt, die Kamera stattdessen mit TweenService zu animieren.Wendet auf jede Fahrt Easing mit TweenService:GetValue an und platziert die Kamera in jedem Frame.
Tweent camera.CFrame und sonst nichtsFocus bleibt, wo die Kamera-Skripte ihn gelassen haben, nahe am Charakter, also wird dynamisches Licht weit weg davon eventuell nicht gerendert (Roblox-Referenz zu Camera.Focus).Setzt Focus in jedem Frame im Render-Step.
Gibt die Kamera nie zurückDer Spieler schaut für immer auf die letzte Einstellung.Setzt am Ende CameraType auf Custom und CameraSubject auf den Humanoid, auch nach einem Skip.
Startet die Cutscene über Touched in einem LocalScriptNichts verhindert, dass sie bei jeder Berührung neu läuft, und die Entscheidung liegt auf einem Gerät, das der Spieler kontrolliert.Der Server wählt den Spieler aus und merkt sich, wer sie gesehen hat.
Liest die Kamera-Parts auf dem ClientMit Streaming an existieren Parts weit weg vom Charakter auf dem Gerät eventuell noch nicht.Der Server liest die Parts, schickt ihre CFrames und fordert den Bereich jeder Einstellung kurz bevor die Kamera dort ankommt an.

Was ein Spieler ändern kann und was nicht

Geh davon aus, dass ein Cheater alles auf seinem eigenen Gerät kontrolliert: Er kann CutscenePlayer bearbeiten oder löschen und CutsceneEvent mit jedem Wert feuern. Bei einer Cutscene spielt das kaum eine Rolle, solange nichts Echtes davon abhängt.

Was ein Cheater versuchen kann und was passiert
Ein Cheater versuchtErgebnis
Eine Cutscene zu überspringen oder nie abzuspielenErlaubt: Es ist sein eigener Bildschirm. Gib nie eine Belohnung für "Cutscene zu Ende geschaut".
CutsceneEvent mit einem beliebigen Wert zu feuernNur eine Zahl, die zu seiner eigenen aktuellen Cutscene passt, bewirkt etwas, und alles, was sie bewirkt, ist, ihn früher freizugeben.
Einen Trigger von irgendwo auf der Map zu berührenMöglich: Jedes Gerät kontrolliert seinen eigenen Charakter, und die Sicherheits-Docs von Roblox nennen das Manipulieren von Touched-Events unter den Dingen, die es tun kann. Er sieht diese Cutscene einmal, und sonst passiert nichts.
Sich während einer Cutscene trotzdem zu bewegenNichts zu gewinnen. Das Festhalten hält ehrliche Spieler davon ab, mitten in der Cutscene wegzulaufen; es ist keine Sicherheitsprüfung.
Das Remote zu nutzen, um für jemand anderen eine Cutscene zu startenNicht möglich. Nur der Server feuert CutsceneEvent an einen Spieler, und die einzige Nachricht, die ein Gerät zurückschicken kann, ist "diese Cutscene ist zu Ende".

Wenn eine Cutscene zu etwas Echtem führt, etwa einer Tür, die sich danach öffnet, oder einem Boss, der erscheint, lass das den Server mit seinem eigenen Timer erledigen, nicht dann, wenn das Gerät sagt, die Cutscene sei zu Ende.

Schritt 5: Testen

  1. Platziere die drei Intro-Einstellungen mit der Command-Bar-Zeile. Gib Einstellung 1 die Caption "Welcome to the village", Einstellung 2 MoveSeconds 2.5 und die Caption "Find the bridge", und lass Einstellung 3 ohne Attribute.
  2. Drück auf Play (F5). Schwarze Balken erscheinen, und die Kamera schneidet auf Einstellung 1 mit ihrem Untertitel, gleitet in 2,5 Sekunden zu Einstellung 2 und dann in 3 Sekunden ohne Untertitel zu Einstellung 3. Danach kommt die Kamera hinter deinen Charakter zurück, und die Spielerliste ist wieder da. Während sie läuft, kannst du nicht laufen.
  3. Stopp, drück noch mal auf Play und drück auf Skip, während die Kamera zu Einstellung 2 gleitet. Die Kamera kommt sofort zurück, und du kannst gleich laufen.
  4. Lauf in BridgeTrigger: Die Bridge-Cutscene läuft. Lauf noch mal durch: Nichts passiert.
  5. Wähl im Dropdown für den Testmodus Server & Clients, stell 2 Clients ein und drück auf Play. Wenn Client 1 in den Trigger läuft, läuft die Bridge-Cutscene nur auf Client 1, und Client 2 kann weiterlaufen.
  6. Lass Workspace.StreamingEnabled an und setz eine Einstellung weit weg vom Spawn. Die Umgebung sollte da sein, wenn die Kamera ankommt (wahrscheinlich, nicht garantiert: siehe Streaming).
  7. Für einen Controller: Stopp, drück auf Play, öffne den Controller Emulator (Tab Emulation, dann Controller) und lauf mit dem emulierten Gamepad in BridgeTrigger: Skip sollte ausgewählt sein, also überspringt A. Wenn du den Device Simulator von Studio nutzt (als wir am 15. Oktober 2026 nachgesehen haben, eine Beta: einschalten unter File, Beta Features, New Device Simulator, dann Studio neu starten), wähl ein Handy, dreh es ins Querformat und prüf, dass Skip nicht unter der Kamera-Notch sitzt und gut antippbar ist, und dass Thumbstick und Sprung-Button während der Cutscene ausgeblendet sind.
  8. Wenn du auch das Hauptmenü gebaut hast, drück auf Play, dann auf den Play-Button des Menüs, und lass das Intro bis zum Ende laufen: Danach sollte die Spielerliste wieder auf dem Bildschirm sein.

Lass das Output-Fenster (Menü Window, dann Output) die ganze Zeit offen. Diese Skripte geben nichts aus, wenn sie funktionieren, also ist jede Warnung oder jeder rote Fehler von CutsceneService oder CutscenePlayer ein echtes Problem. Siehe Häufige Fehler.

Erweitern

Das Intro nur beim ersten Besuch eines Spielers zeigen

Die Tabelle seen gilt für einen Server, also sieht ein Spieler, der neu beitritt, das Intro noch einmal. Um es nur beim ersten Besuch zu zeigen, speichere ein Flag wie SeenIntro mit seinen restlichen Daten, über das Modul PlayerData aus dem DataStore-Tutorial. Lass INTRO_CUTSCENE wie es ist und ändere den Intro-Teil von onCharacterAdded in CutsceneService: Warte, bis PlayerData.Get(player) die Daten des Spielers zurückgibt, überspring das Intro, wenn data.SeenIntro true ist, und setz data.SeenIntro = true nur, wenn playOnce(player, INTRO_CUTSCENE) true zurückgibt. Starte das Intro nicht aus dem Code, der die Daten lädt: Die Daten können fertig geladen sein, bevor der Charakter spawnt, und play tut ohne Charakter nichts, also würde das Flag für ein Intro gespeichert, das niemand gesehen hat.

Charaktere, die in der Cutscene spielen

Erstelle die Animation im Animation Editor von Studio oder in einem Animations-Plugin eines Drittanbieters wie Moon Animator, das die Roblox-Docs selbst erwähnen, und spiel sie auf einem NPC-Rig in der Einstellung ab, wenn die Kamera dort ankommt. Laut der Animator-Referenz von Roblox replizieren die Animationen eines NPCs nur, wenn der Server sie lädt und startet, also spiel sie aus einem Server-Script ab, wenn jeder Spieler den NPC spielen sehen soll. In CutscenePlayer geladen und gestartet wird die Animation nicht repliziert, was zu einer Cutscene passt, die nur ein Spieler anschaut. Der Guide zum Animations-Skript zeigt, wie du eine auf einem NPC aus einem Server-Script abspielst.

Dialoge

Untertitel passen zu kurzen Sätzen, die von selbst ablaufen. Für ein Gespräch, in dem der Spieler antwortet und Optionen wählt, siehe den Guide zu NPC-Dialogen.

Ein Intro nach dem Hauptmenü

Der Guide zum Hauptmenü schaltet CharacterAutoLoads aus, also spawnt niemand, bevor er auf Play drückt. CutsceneService spielt das Intro beim ersten Spawn eines Spielers ab, also läuft das Intro mit beiden Systemen beim ersten Spawn nach Play. Das Menü schaltet die Core-GUIs wieder ein, sobald der Charakter erscheint, was passieren kann, während das Intro schon läuft, also kann die Spielerliste während des Intros sichtbar sein. CutscenePlayer schaltet nur die wieder ein, die es selbst ausgeblendet hat, also lässt es die Änderung des Menüs in Ruhe, und sie bleiben nach dem Intro an. Der Command-Bar-Trick aus dem Hauptmenü-Guide zum Ausrichten eines Kamera-Parts ist derselbe, den Schritt 1 nutzt.

Ein Überflug zu Beginn einer Runde

Um eine Cutscene aus einem anderen Server-Skript zu starten, etwa einen Überflug über die Map, wenn eine Runde aus dem Guide zum Rundensystem beginnt, füge ServerStorage ein BindableEvent namens PlayCutscene hinzu. Verbinde am Ende von CutsceneService sein Event mit der Funktion play, und lass das Runden-Skript es mit jedem Spieler und dem Namen der Cutscene feuern. play überspringt die Prüfung "einmal pro Server", also läuft der Überflug jede Runde.

Cutscene-Plugins

Plugins kannst du gut zusammen mit diesem Guide nutzen. Wenn ein Cutscene-Plugin sein eigenes Kamera-Skript schreibt, prüf, dass es die Kamera zurückgibt (CameraType Custom und ein CameraSubject) und Focus setzt, solange die Kamera Scriptable ist, und lass die Entscheidung, wer die Cutscene sieht, wie in diesem Guide auf dem Server.

Häufige Fehler und Lösungen

Öffne das Output-Fenster (Menü Window, dann Output), bevor du auf Play drückst. Die meisten Cutscene-Probleme geben dort entweder eine Warnung aus oder kommen von einem Namen, der nicht passt.

Infinite yield possible on 'Workspace:WaitForChild("Cutscenes")'

CutsceneService wartet auf einen Ordner namens Cutscenes direkt in Workspace. Erstelle ihn wie in Schritt 1 und prüf die Schreibweise und das große C. Solange er nicht existiert, erstellt CutsceneService kein CutsceneEvent, also wartet auch CutscenePlayer.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("CutsceneEvent")'

CutscenePlayer wartet auf das Remote, das CutsceneService erstellt. Prüf, dass CutsceneService ein Script ist, kein LocalScript, direkt in ServerScriptService liegt, nicht deaktiviert ist und dass Output keinen Fehler und keine Cutscenes-Warnung von ihm zeigt.

CutsceneService: no folder named Intro in Workspace.Cutscenes

Der Name in INTRO_CUTSCENE oder im Attribut Cutscene eines Triggers passt zu keinem Ordner in Workspace.Cutscenes. Bei Namen zählt Groß- und Kleinschreibung.

Nichts läuft, und Output zeigt nichts

Der Ordner hat keinen Part namens 1, oder seine Parts liegen nicht direkt darin (zum Beispiel in einem Model). CutsceneService liest Parts namens 1, 2, 3 der Reihe nach und stoppt bei der ersten fehlenden Zahl. Denk auch daran, dass jede Cutscene einmal pro Spieler pro Server läuft: Stopp den Test und drück noch mal auf Play.

Die Kamera zeigt in die falsche Richtung

Die Kamera schaut in dieselbe Richtung wie die Vorderseite des Kamera-Parts. Flieg mit der Studio-Kamera zur gewünschten Ansicht und führe die Command-Bar-Zeile aus Schritt 1 für diese Einstellung erneut aus.

Der Trigger tut nichts

Prüf, dass der Trigger-Part beim Spielstart direkt in Workspace.CutsceneTriggers liegt, dass CanTouch angehakt ist (sonst zeigt Output eine Warnung) und dass sein Attribut Cutscene ein String ist, der einen Ordner in Workspace.Cutscenes nennt. Ein zweites Durchlaufen tut absichtlich nichts.

Die Kamera bleibt nach der Cutscene auf der letzten Einstellung

CutscenePlayer ist mit einem Fehler stehen geblieben, bevor es die Kamera zurückgeben konnte, also such im Output nach einem roten Fehler von ihm. Auch ein anderes Skript, das CameraType immer wieder auf Scriptable setzt, etwa eine Menü-Kamera, die noch gebunden ist, kann die Kamera festhalten.

Mit RoCode bauen

Wenn du das nicht von Hand verdrahten willst, kann RoCode es in dem Place bauen, den 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, und sein Studio-Plugin erstellt den Part und die Skripte in deinem Explorer, also kopierst du keinen Code aus einem Chatfenster. Prompts kannst du auf Deutsch schreiben.

Du schreibst

Füge eine Intro-Cutscene hinzu: ein Ordner Cutscenes mit einem Ordner Intro mit den Einstellungen 1 bis 3, Untertitel aus einem Caption-Attribut, schwarze Balken und ein Skip-Button, einmal abgespielt, wenn ein Spieler zum ersten Mal spawnt, der Server hält den Spieler fest, und am Ende wird die Kamera zurückgegeben.

RoCode macht
  • Kann zuerst mit Search Scripts deinen Place prüfen, zum Beispiel auf ein Menü- oder Kamera-Skript, das schon CameraType setzt, damit sich die beiden nicht in die Quere kommen
  • Erstellt die Ordner und den Trigger-Part mit Create Instance und setzt Attribute wie Caption und MoveSeconds an den Parts
  • Schreibt CutsceneService und CutscenePlayer mit Create Script
  • Ist angewiesen, jedes Skript, das es schreibt, mit Check Script zu prüfen; das kompiliert es in Studio, ohne es auszuführen. Setzt vor und nach jeder Änderungsrunde einen Undo-Punkt

Platziere die Kamera-Parts selbst, indem du mit der Studio-Kamera zu jeder Ansicht fliegst, und frag dann nach den Skripten. Mit Plugin 3.9 oder neuer kann RoCode einen kurzen Playtest machen und die Fehler lesen, und mit Plugin 3.9.11 oder neuer kann es einen Test-Charakter steuern, um zu prüfen, ob das Spiel funktioniert, aber es macht keine Screenshots, während das Spiel läuft, also schaust du dir die Cutscene selbst an. In welcher Reihenfolge du ein ganzes Spiel baust, steht unter ein Roblox-Spiel mit KI bauen, System für System. Wie sich RoCode mit Studio verbindet.

Häufige Fragen

Wie lasse ich eine Cutscene abspielen, wenn ein Spieler beitritt?

Nenn einen Ordner mit Einstellungen in Workspace.Cutscenes Intro, oder ändere INTRO_CUTSCENE auf den Namen deines Ordners. CutsceneService spielt ihn beim ersten Spawn jedes Spielers auf einem Server ab. Um ihn nur beim allerersten Besuch zu zeigen, speichere ein Flag in einem Data Store und setz es erst, wenn das Intro gestartet ist, wie unter Erweitern beschrieben.

Kann ich eine Cutscene ohne Plugins erstellen?

Ja. Dieser Guide nutzt nur Parts, Attribute und zwei Skripte, und die Command-Bar-Zeile setzt jede Einstellung genau dorthin, wo die Studio-Kamera ist. Plugins wie Moon Animator sind trotzdem praktisch, um Charaktere zu animieren, die in der Cutscene spielen.

Warum bewegt sich meine Kamera in der Cutscene nicht?

Meistens steht der Kamera-Code in einem Server-Script, aber nur ein LocalScript kann die Kamera eines Spielers bewegen, weil jedes Gerät seine eigene hat. Die andere häufige Ursache: CameraType ist nicht Scriptable, also bewegen die Standard-Kamera-Skripte von Roblox die Kamera immer wieder zum Charakter zurück.

Wie verhindere ich, dass sich der Spieler während einer Cutscene bewegt?

Verankere seinen HumanoidRootPart auf dem Server, solange sie läuft, und löse die Verankerung danach, wie CutsceneService es macht. Ein verankerter Part bewegt sich nie durch Physik. WalkSpeed bleibt unangetastet, also kommt es sich nicht mit einem Sprint-Skript oder einem Speed-Pass in die Quere.

Wie füge ich einer Cutscene einen Skip-Button hinzu?

Setz einen TextButton auf den Cutscene-Bildschirm und verbinde sein Activated-Event, das bei einem Klick, einem Antippen oder der A-Taste eines Controllers feuert, sobald der Button ausgewählt ist. Der Skip von CutscenePlayer setzt ein Flag, das die Schleife über die Einstellungen in jedem Frame prüft, wird für Gamepad-Spieler automatisch ausgewählt und sitzt in einem eigenen ScreenGui mit den Standard-Insets, damit die Kamera-Notch eines Handys ihn nicht verdecken kann. Thumbstick und Sprung-Button sind während der Cutscene ausgeblendet, also sitzen sie nicht daneben.

Warum ist die Welt in meiner Cutscene leer?

Mit Instance Streaming an hat das Gerät eines Spielers nur den Bereich nahe seinem Charakter. Lass den Server für jede Einstellung kurz bevor die Kamera dort ankommt player:RequestStreamAroundAsync aufrufen, wie CutsceneService es macht. Roblox sagt, dass der Bereich dadurch wahrscheinlich, aber nicht sicher geladen ist, also halt wichtige Einstellungen innerhalb deines Streaming-Radius, oder nutze Player:AddReplicationFocus für einen Bereich, der geladen bleiben muss.

Quellen und weiterführende Links

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, 14. November 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.

Probier RoCode in deinem eigenen Spiel aus.

Jeden Tag kostenlose Credits, ohne Karte. Installiere das Plugin, beschreibe das Feature und prüfe, was in Studio ankommt.