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.Focusnicht 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:Interpolateist veraltet (deprecated). Die Roblox-Referenz sagt, die Kamera stattdessen mit TweenService zu animieren.
Auf dieser Seite
So funktioniert eine Cutscene
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:
- Der Server entscheidet, dass ein Spieler eine Cutscene sehen soll: das
Introbei seinem ersten Spawn auf dem Server, oder eine andere, wenn er einen Trigger-Part berührt. - 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
CutsceneEventnur an diesen Spieler, mit einer ID und der Liste der Einstellungen. - 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.
- Wenn die letzte Einstellung endet oder der Spieler auf Skip drückt, gibt es die Kamera an den Charakter zurück und feuert
CutsceneEventmit derselben ID an den Server. - 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.
| Teil | Wo es liegt | Was es tut |
|---|---|---|
Das Script CutsceneService | ServerScriptService | Entscheidet, wer welche Cutscene wann sieht, liest die Einstellungen, hält den Spieler fest und merkt sich, wer was gesehen hat. |
Das LocalScript CutscenePlayer | StarterPlayer, StarterPlayerScripts | Spielt eine Cutscene auf dem Bildschirm des Spielers ab: Balken, Untertitel, Skip und die Kamerafahrten. Gibt die Kamera am Ende zurück. |
Das RemoteEvent CutsceneEvent | ReplicatedStorage (CutsceneService erstellt es) | Bringt die Einstellungen vom Server zu einem Spieler und die Nachricht "Cutscene zu Ende" zurück. |
Der Ordner Cutscenes | Workspace | Ein Ordner pro Cutscene, etwa Intro, mit den Kamera-Parts 1, 2, 3. |
Der Ordner CutsceneTriggers | Workspace (optional) | Parts, die eine Cutscene starten, wenn ein Spieler sie berührt. |
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.
- Fahr im Explorer mit der Maus über Workspace, klick auf + und füge einen Folder namens
Cutscenesein. Füge darin einen Folder namensIntroein. Bei Namen zählt Groß- und Kleinschreibung. - Flieg mit der Studio-Kamera zur ersten Ansicht, die du willst, als würdest du ein Foto einrahmen.
- Füge einen Part in Intro ein und benenne ihn in
1um. - Öffne die Command Bar (im Tab Script, oder über Window, dann Script) und führe
workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrameaus. Im Bearbeitungsmodus istCurrentCameradie 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. - 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.
- Wiederhole das für die nächsten Ansichten, nenn die Parts
2,3und 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.
| Attribut | Typ | Standard | Was es tut |
|---|---|---|---|
MoveSeconds | number | 3 | Sekunden, 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. |
HoldSeconds | number | 1 | Sekunden, die die Kamera nach der Ankunft auf dieser Einstellung bleibt. |
Caption | string | keiner | Text 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.
-- 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.
| Einstellung | Wert hier | Was 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_SECONDS | 3 | Wie lange eine Fahrt dauert, wenn eine Einstellung kein MoveSeconds-Attribut hat. |
DEFAULT_HOLD_SECONDS | 1 | Wie lange die Kamera auf einer Einstellung bleibt, wenn sie kein HoldSeconds-Attribut hat. |
MAX_SHOTS | 30 | Die 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.
readShotssammelt 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.
playtut 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.delaygibt 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
seenmerkt 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.playOncegibt 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
- Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts und füge ein LocalScript namens
CutscenePlayerein. - Ersetze seinen Inhalt durch den Code unten.
-- 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.
| Teil | Was er tut |
|---|---|
Das ScreenGui Cutscene | Zwei 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 CutsceneControls | Enthä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_GUIS | Blendet 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. |
TouchControlsEnabled | Auf 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. |
updateCamera | Lä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. |
waitOrSkip | Wartet die Fahr- und Haltezeit einer Einstellung ab und prüft dabei in jedem Frame das Skip-Flag. |
play | Macht 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-Button | Activated 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.
- Füge in Workspace, Cutscenes einen Folder namens
Bridgeein und platziere seine Einstellungen wie in Schritt 1, mit den Namen1und2. Nimm in der Command-Bar-ZeileBridgestattIntro. - Fahr mit der Maus über Workspace und füge einen Folder namens
CutsceneTriggersein. - Füge darin einen Part namens
BridgeTriggerein. 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. - Gib ihm ein Attribut namens
Cutscenevom Typ string und setz den Wert aufBridge: 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_STYLE | Wie sich die Fahrt anfühlt |
|---|---|
Enum.EasingStyle.Sine (hier genutzt) | Die Geschwindigkeit folgt einer Sinuskurve, für einen sanften Start und Stopp. |
Enum.EasingStyle.Quad | Wie Sine, mit einer etwas schärferen Kurve. |
Enum.EasingStyle.Linear | Konstante 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.
| Das Tutorial | Das Problem | Dieser 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 nichts | Focus 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ück | Der 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 LocalScript | Nichts 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 Client | Mit 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.
| Ein Cheater versucht | Ergebnis |
|---|---|
| Eine Cutscene zu überspringen oder nie abzuspielen | Erlaubt: Es ist sein eigener Bildschirm. Gib nie eine Belohnung für "Cutscene zu Ende geschaut". |
CutsceneEvent mit einem beliebigen Wert zu feuern | Nur 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ühren | Mö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 bewegen | Nichts 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 starten | Nicht 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
- Platziere die drei Intro-Einstellungen mit der Command-Bar-Zeile. Gib Einstellung 1 die
Caption"Welcome to the village", Einstellung 2MoveSeconds2.5 und dieCaption"Find the bridge", und lass Einstellung 3 ohne Attribute. - 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.
- 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.
- Lauf in BridgeTrigger: Die Bridge-Cutscene läuft. Lauf noch mal durch: Nichts passiert.
- 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.
- Lass
Workspace.StreamingEnabledan und setz eine Einstellung weit weg vom Spawn. Die Umgebung sollte da sein, wenn die Kamera ankommt (wahrscheinlich, nicht garantiert: siehe Streaming). - 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.
- 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.
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.
- Kann zuerst mit Search Scripts deinen Place prüfen, zum Beispiel auf ein Menü- oder Kamera-Skript, das schon
CameraTypesetzt, 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
- Roblox Creator Docs: Customize the camera (auf Englisch). die eigene Camera jedes Clients, Scriptable, CFrame und Focus
- Roblox Engine API: Camera (auf Englisch). CameraType, CameraSubject, Focus in jedem Frame und das veraltete Interpolate
- Roblox Creator Docs: Control the user's camera (auf Englisch). BindToRenderStep eine Prioritätsstufe nach der Kamera
- Roblox Engine API: TweenService:GetValue (auf Englisch). Alpha mit Easing, begrenzt auf 0 bis 1
- Roblox Engine API: ScreenGui.ScreenInsets (auf Englisch). warum None nur für Inhalte ist, auf die man nicht drückt
- Roblox Creator Docs: Instance streaming (auf Englisch). standardmäßig an in neuen Places, und der Replication Focus
- Roblox Creator Docs: Streaming techniques (auf Englisch). einen Bereich vorladen, bevor ein Event gefeuert wird
- Roblox Engine API: Player:RequestStreamAroundAsync (auf Englisch). eine vorübergehende Anfrage ohne Garantie
- Roblox Creator Docs: Remote events and callbacks (auf Englisch). gepufferte Nachrichten und welche Tabellen sich schicken lassen
- Roblox Creator Docs: Network ownership, movement validation, and physics (auf Englisch). was ein Client mit seinem eigenen Charakter tun kann, auch Touched-Events manipulieren
- Roblox Engine API: Animator:LoadAnimation (auf Englisch). welche Animationen replizieren
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.