Tutorial · Gamesystemen

Hoe maak je een cutscene in Roblox Studio

Een cutscene in Roblox is een camera die een paar seconden de besturing overneemt: hij springt of vliegt vloeiend tussen shots, laat een ondertitel zien en geeft de besturing terug aan de speler. In deze handleiding bouwen we een cutscene die je instelt door onzichtbare parts neer te zetten waar de camera moet staan, zonder plugins. De server bepaalt wanneer de speler hem ziet (bij de eerste spawn of bij het aanraken van een trigger), en het apparaat van de speler beweegt de camera, laat zwarte balken en een knop Skip zien en geeft de camera terug.

Bijgewerkt 20 november 202625 min lezenAuteur:

In het kort

Zet onzichtbare geankerde parts met de namen 1, 2, 3 in een map binnen Workspace.Cutscenes, elk met de voorkant gericht waar de camera naar moet kijken. Een Script in ServerScriptService leest hun CFrame, houdt de speler op zijn plek en stuurt de shots via een RemoteEvent naar die speler. Een LocalScript in StarterPlayerScripts zet workspace.CurrentCamera.CameraType op Scriptable, beweegt de camera elk frame van shot naar shot (vloeiend gemaakt met TweenService:GetValue) en zet daarna CameraType terug op Custom en CameraSubject op de Humanoid van de speler.

  • Alleen het apparaat van de speler kan de camera besturen, dus de cameracode is een LocalScript. De server bepaalt alleen wie welke cutscene ziet en wanneer.
  • Als de camera Scriptable is, werkt Roblox Camera.Focus niet meer bij. De referentie zegt dat je Focus elk frame moet bijwerken, anders wordt dynamische belichting ver van de oude focus misschien niet getekend.
  • Camera:Interpolate is verouderd. De referentie van Roblox zegt dat je de camera met TweenService moet animeren.
Op deze pagina
  1. Hoe het werkt
  2. 1. Shots
  3. 2. Serverscript
  4. 3. LocalScript
  5. 4. Trigger
  6. Cameradetails
  7. Oude tutorials
  8. Bescherming tegen cheats
  9. 5. Testen
  10. Uitbreiden
  11. Common errors
  12. Met RoCode
  13. Veelgestelde vragen
  14. Bronnen en verder lezen

Hoe een cutscene werkt

IllustratieEen intro van twee shots op echte snelheid: sprong naar het eerste shot, pauze van 1 seconde, vlucht naar de brug in 2.5 seconden, pauze van 1 seconde, daarna gaat de camera terug naar de speler.

Elk apparaat van een speler heeft zijn eigen Camera-object, in workspace.CurrentCamera, dus alleen een LocalScript kan bewegen wat de speler ziet. Bepalen wie welke cutscene ziet en wanneer, is het werk van de server. De handleiding verdeelt het werk precies zo. Eén cutscene gaat zo:

  1. De server besluit dat de speler een cutscene moet zien: Intro bij de eerste spawn op de server, of een andere als hij een triggerpart aanraakt.
  2. CutsceneService leest de CFrame en de instellingen van de shotparts, vraagt Roblox het gebied van het eerste shot voor deze speler te laden, ankert de HumanoidRootPart van de speler zodat hij stil blijft staan, en stuurt CutsceneEvent alleen naar deze speler met een id en de lijst met shots.
  3. CutscenePlayer op het apparaat van de speler laat zwarte balken en een knop Skip zien, verbergt de spelerslijst, de rugzak, de gezondheidsbalk en de touchbediening, maakt de camera Scriptable en beweegt hem elk frame.
  4. Als het laatste shot klaar is of de speler op Skip drukt, geeft hij de camera terug aan het personage en stuurt hij de server CutsceneEvent met hetzelfde id.
  5. De server haalt het anker van de speler weg. Komt dat bericht nooit aan, dan haalt hij het anker toch weg als de lengte van de cutscene plus 2 seconden voorbij is. De timer start als de server de cutscene verstuurt, en bij langzaam joinen kan het apparaat de intro een paar seconden later starten, omdat een LocalScript buiten ReplicatedFirst pas draait als de game geladen is. Dan kan de speler weer bewegen voordat de intro op zijn scherm klaar is.
Waar het cutscenesysteem uit bestaat
OnderdeelWaar het staatWat het doet
Script CutsceneServiceServerScriptServiceBepaalt wie welke cutscene ziet en wanneer, leest de shots, houdt de speler op zijn plek en onthoudt wie wat al gezien heeft.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsSpeelt de cutscene af op het scherm van de speler: balken, ondertitels, Skip en de camerabeweging. Geeft aan het eind de camera terug.
RemoteEvent CutsceneEventReplicatedStorage (CutsceneService maakt hem)Brengt de shots van de server naar één speler en het bericht "cutscene is klaar" terug.
Folder CutscenesWorkspaceEén map per cutscene, bijvoorbeeld Intro, met de shotparts 1, 2, 3.
Folder CutsceneTriggersWorkspace (optioneel)Parts die een cutscene starten als een speler ze aanraakt.
De Explorer als het cutscenesysteem klaar is. De mappen Bridge en CutsceneTriggers komen erbij in stap 4. Als de game start, voegt CutsceneService een RemoteEvent met de naam CutsceneEvent toe aan ReplicatedStorage.
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

Stap 1: Zet de camerashots neer

Elk shot is een onzichtbaar part. De camera neemt de positie van het part en kijkt dezelfde kant op als de voorkant ervan, dus een shot neerzetten is de camera neerzetten.

  1. Ga in de Explorer met je muis over Workspace, klik op de knop + en voeg een Folder toe met de naam Cutscenes. Voeg daarbinnen een Folder toe met de naam Intro. Hoofdletters in de namen tellen mee.
  2. Beweeg de Studio-camera naar het eerste beeld dat je wilt, alsof je een foto kadreert.
  3. Voeg een Part toe aan Intro en hernoem het naar 1.
  4. Open de Command Bar (op het tabblad Script of via Window, dan Script) en voer workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame uit. In de bewerkmodus is CurrentCamera het beeld waar je doorheen kijkt, dus het part komt precies in dit shot te staan. De haken en aanhalingstekens zijn nodig omdat je een naam die met een cijfer begint niet na een punt kunt schrijven.
  5. Vink in de Properties van het part Anchored aan, vink CanCollide, CanTouch en CanQuery uit en zet Transparency op 1. Anchored voorkomt dat het door de map zakt; de rest voorkomt dat het spelers in de weg zit, aanraakevents afvuurt en raycasts blokkeert.
  6. Herhaal dit voor de volgende beelden, noem de parts 2, 3 enzovoort en verander het nummer in de regel voor de Command Bar. CutsceneService speelt de shots op volgorde van nummer af en stopt bij het eerste ontbrekende nummer, dus een gat in de nummering breekt de cutscene te vroeg af.

Om een shot later te veranderen, beweeg je de camera naar het nieuwe beeld en voer je dezelfde regel uit met het nummer van dat shot. Met Transparency 1 zijn de parts ook in Studio onzichtbaar, dus selecteer ze in de Explorer als je ze nodig hebt.

Elk shot kan nog drie optionele attributen hebben. Om een attribuut toe te voegen selecteer je het part, scrol je in het venster Properties naar het gedeelte Attributes, klik je op +, typ je de naam, kies je het type en klik je op Save.

Optionele attributen op elk shotpart
AttribuutTypeStandaardWat het doet
MoveSecondsnumber3Hoeveel seconden de camera van het vorige shot naar dit shot vliegt. 0 geeft een harde overgang. Shot 1 is altijd een harde overgang, dus daar werkt het attribuut niet.
HoldSecondsnumber1Hoeveel seconden de camera na aankomst op dit shot blijft staan.
CaptionstringgeenTekst op de onderste balk vanaf het moment dat de camera naar dit shot begint te vliegen. Een shot zonder Caption maakt de tekst leeg.

Een getal kleiner dan 0 of groter dan 60, en een attribuut van het verkeerde type, worden vervangen door de standaardwaarde.

Stap 2: Voeg het serverscript toe

Ga met je muis over ServerScriptService, voeg een Script toe met de naam CutsceneService en plak de code hieronder erin. De instellingen bovenaan zijn de regels die je kunt aanpassen.

Script in ServerScriptService met de naam CutsceneService
-- Script in ServerScriptService met de naam CutsceneService.
-- Bepaalt wie welke cutscene ziet en wanneer. Leest de camerashots uit genummerde
-- parts in Workspace.Cutscenes, houdt de speler op zijn plek en zegt tegen het apparaat
-- van die speler dat het de shots moet afspelen. De camera zelf kan alleen op het apparaat bewegen.

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

-- Instellingen
local INTRO_CUTSCENE = "Intro" -- speelt één keer bij de eerste spawn van de speler; "" om uit te zetten
local DEFAULT_MOVE_SECONDS = 3 -- tijd van de vlucht naar een shot als die geen MoveSeconds heeft
local DEFAULT_HOLD_SECONDS = 1 -- tijd op een shot als die geen HoldSeconds heeft
local MAX_SHOTS = 30

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

-- Dit script maakt CutsceneEvent zelf, dus voeg hem niet met de hand toe
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 } = {} -- id van de cutscene die de speler bekijkt
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

-- Shots zijn de parts 1, 2, 3 ... in een map met de naam van de cutscene
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,
			-- het eerste shot is een harde overgang, dus de camera springt er meteen heen
			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 -- deze cutscene is al afgelopen
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- één cutscene tegelijk
	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

	-- Met instance streaming aan heeft het apparaat van de speler misschien niet het gebied
	-- waar het shot naar kijkt, en een verzoek laadt een gebied maar tijdelijk. We laden
	-- het gebied van het eerste shot nu (wachten tot 2 seconden), en dat van elk volgend
	-- shot 2 seconden voordat de camera erheen vliegt.
	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 -- de speler ging weg terwijl het gebied laadde
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- seconden vanaf nu tot de vlucht naar dit shot begint
	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
	-- Vangnet: de speler ontdooien, ook als zijn apparaat nooit antwoordde
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Geeft alleen true terug als de cutscene voor deze speler gestart is
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

-- Het apparaat van de speler meldt dat de cutscene klaar is of overgeslagen
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Triggerparts: aanraken start de cutscene uit hun attribuut Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Touched koppelen aan een part met CanTouch uit geeft een fout, dus we waarschuwen alleen
			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) -- respawn tijdens een cutscene, houd ook het nieuwe personage op zijn plek
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- al ingesteld
	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 -- iedereen die binnenkwam terwijl het script op Cutscenes wachtte
	onPlayerAdded(player)
end

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

CutsceneService maakt de RemoteEvent CutsceneEvent zelf, zodra Workspace.Cutscenes bestaat, dus je hoeft niets met de hand in ReplicatedStorage te zetten. Heb je al een RemoteEvent met die naam gemaakt, verwijder die dan: het LocalScript kan de jouwe vinden, en daar luistert op de server niemand naar.

Instellingen bovenaan CutsceneService
InstellingWaarde hierWat het verandert
INTRO_CUTSCENE"Intro"De map in Workspace.Cutscenes die speelt bij de eerste spawn van de speler op de server. Zet hem op "" voor geen intro.
DEFAULT_MOVE_SECONDS3Hoe lang een vlucht duurt als het shot geen attribuut MoveSeconds heeft.
DEFAULT_HOLD_SECONDS1Hoe lang de camera op een shot blijft als het geen attribuut HoldSeconds heeft.
MAX_SHOTS30Het hoogste shotnummer dat CutsceneService in één cutscene zoekt.

Wat de rest van het script doet, op volgorde:

  • Leest de shots op de server. readShots verzamelt de CFrame en de attributen van elk genummerd part in een lijst. Het apparaat van de speler krijgt die lijst, dus de parts zelf heeft het niet nodig.
  • Eén cutscene tegelijk. play doet niets zolang de speler al een cutscene bekijkt, of als zijn personage geen Humanoid heeft of dood is.
  • Elke cutscene heeft een eigen id. Het apparaat stuurt het id terug als de cutscene klaar is of overgeslagen, en alleen een overeenkomend id ontdooit de speler, dus een te laat bericht van een vorige cutscene kan een nieuwe niet beëindigen.
  • Houdt de speler op zijn plek door zijn HumanoidRootPart te ankeren, en ankert het nieuwe personage als de speler midden in een cutscene respawnt. De referentie van Roblox zegt dat een geankerd part nooit van positie verandert door zwaartekracht, botsingen of andere fysica. WalkSpeed wordt niet aangeraakt, dus het botst niet met een sprintscript of een speedpass. Aan het eind haalt het script het anker van de root part weg, ook als een ander script hem had geankerd, dus anker personages nergens anders zolang er een cutscene kan lopen.
  • Vangnet. task.delay ontdooit de speler na de volledige lengte van de cutscene plus 2 seconden, ook als zijn apparaat nooit antwoordde.
  • Elke cutscene één keer per server. De tabel seen onthoudt per speler welke cutscenes al begonnen zijn, dus de intro herhaalt niet bij een respawn en een cutscene van een trigger speelt één keer. playOnce geeft alleen true terug als de cutscene echt gestart is.
  • Stelt elke speler in. De lus over Players:GetPlayers() aan het eind pakt iedereen op die binnenkwam terwijl het script op de map Cutscenes wachtte.

De shots gaan in één aanroep van FireClient naar de speler, als een lijst kleine tabellen. De pagina van Roblox over remote events zegt dat je geen tabel moet sturen waarin numerieke en tekstsleutels gemengd zijn; deze lijst heeft alleen numerieke sleutels en elk shot daarbinnen alleen tekstsleutels, de vorm die daar wordt aangeraden.

Stap 3: Voeg het LocalScript toe dat hem afspeelt

  1. Klap in de Explorer StarterPlayer uit, ga met je muis over StarterPlayerScripts en voeg een LocalScript toe met de naam CutscenePlayer.
  2. Vervang de inhoud door de code hieronder.
LocalScript in StarterPlayerScripts met de naam CutscenePlayer
-- LocalScript in StarterPlayer > StarterPlayerScripts met de naam CutscenePlayer.
-- Speelt de cutscene af die de server stuurt: zwarte balken, ondertitels, een knop Skip en
-- een camera die van shot naar shot vliegt. Geeft daarna de camera terug aan de speler.

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 -- elke zwarte balk, als deel van de schermhoogte
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- hoeveel studs voor de camera Roblox het meest gedetailleerd moet tekenen
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 }

-- Het cutscenescherm: twee zwarte balken en een ondertitel, van rand tot rand. Roblox raadt
-- ScreenInsets None alleen aan voor dingen die niemand aanklikt, daarom heeft Skip hieronder een eigen ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- over het hele scherm
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

-- De knop Skip heeft de standaardmarges, dus de camera-uitsparing bedekt hem niet
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) -- op de onderste balk, 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 blijft groot genoeg om op een kleine telefoon te raken
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

-- De huidige vlucht: van de ene camera-CFrame naar de volgende in een gegeven aantal seconden
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Draait elk frame tijdens een cutscene. De Focus van een Scriptable camera volgt zelf
-- niets, dus die wordt hier ook ingesteld.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- iets heeft hem teruggezet, bijvoorbeeld een 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
		-- Er speelt er al een, dus laat de server de speler voor deze meteen ontdooien
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Verberg de spelerslijst, de rugzak en de gezondheidsbalk, en onthoud wat zichtbaar was
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- Verberg op telefoons de joystick en de springknop, die in de onderste hoeken staan
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- Een gamepad kan alleen de geselecteerde knop indrukken, dus voor gamepadspelers selecteren we Skip
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Eén stap na de eigen camera-update van Roblox, zoals in de cameratutorial van Roblox
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- begin elke vlucht waar de camera nu is
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- Geef de camera terug aan het personage van de speler
	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 = ""
	-- Zet alleen terug aan wat deze cutscene uitzette, de rest blijft zoals het is
	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) -- de server ontdooit de speler meteen
	busy = false
end

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

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

Een LocalScript in StarterPlayerScripts wordt één keer naar de speler gekopieerd, bij het joinen, en blijft werken na een respawn van het personage. Daarom staat ResetOnSpawn bij beide ScreenGuis uit: zet je het aan, dan verwijdert Roblox ze bij de eerste respawn, en dit script maakt ze niet opnieuw. Berichten van de remote die aankomen voordat het script aan OnClientEvent gekoppeld is, worden in een wachtrij gezet en na het koppelen afgeleverd, dus een speler die snel spawnt, ziet de intro toch.

Wat elk deel van CutscenePlayer doet
DeelWat het doet
ScreenGui CutsceneTwee zwarte balken, elk 12% van de schermhoogte (BAR_HEIGHT), en een ondertitel op de onderste balk. ScreenInsets None rekt de balken uit tot de uiterste randen van het scherm, en DisplayOrder 10 tekent ze boven ScreenGuis met een lagere DisplayOrder.
ScreenGui CutsceneControlsBevat alleen de knop Skip, rechts op de onderste balk, met een UISizeConstraint die hem minstens 64 bij 32 pixels houdt, zodat hij op een telefoon makkelijk te raken is. Hij heeft de standaard ScreenInsets, en de inhoud schuift niet onder de knoppen van de bovenbalk van Roblox en de camera-uitsparingen. Roblox raadt None alleen aan voor inhoud waar niets op te klikken valt, daarom kan Skip niet in de ScreenGui met de balken staan.
HIDDEN_CORE_GUISVerbergt de spelerslijst, de rugzak en de gezondheidsbalk met SetCoreGuiEnabled, nadat hij met GetCoreGuiEnabled onthouden heeft welke aan stonden, en zet aan het eind alleen terug aan wat hij zelf uitzette. Verbergt je game de rugzak ergens anders, dan blijft die verborgen, en een script dat ze tijdens de cutscene aanzet, bijvoorbeeld een hoofdmenu, wordt door niemand overschreven.
TouchControlsEnabledOp telefoons en tablets zet play tijdens de cutscene GuiService.TouchControlsEnabled op false. Dat verbergt de joystick en de springknop, die in de onderste hoeken staan, op dezelfde plek als Skip, en aan het eind komen ze terug als ze aan stonden.
updateCameraDraait elk frame zolang de cutscene loopt. Berekent welk deel van de huidige vlucht voorbij is, maakt dat vloeiend met TweenService:GetValue, zet de camera tussen twee shots met CFrame:Lerp en zet Focus 30 studs voor de camera.
waitOrSkipWacht de tijd van de vlucht en de pauze van het shot, en controleert elk frame de Skip-vlag.
playMaakt de camera Scriptable, speelt de shots op volgorde, geeft daarna de camera terug (CameraType Custom, CameraSubject is de Humanoid), zet de core GUI en de touchbediening weer aan en stuurt de server het id van de cutscene. Komt er een tweede cutscene binnen terwijl de eerste nog speelt, dan stuurt hij het id ervan meteen terug, zodat de server de speler niet vasthoudt voor een cutscene die dit apparaat niet liet zien.
Knop SkipActivated gaat af bij een muisklik, een tik of de knop A op een gamepad als de knop geselecteerd is. Voor een speler wiens hoofdinvoer een gamepad is, selecteert play Skip aan het begin van de cutscene en heft de selectie aan het eind op.

Verander BAR_HEIGHT om de balken dunner of dikker te maken, en EASING_STYLE om het gevoel van de vluchten te veranderen (zie Wat de cameracode goed doet). Bij de ondertitel en de knop Skip staat TextScaled aan, dus de tekst groeit en krimpt mee met het scherm.

Stap 4: Een cutscene bij het aanraken van een part

De intro speelt vanzelf. Voor een cutscene op een bepaalde plek op de map, bijvoorbeeld als de speler voor het eerst bij de brug komt, voeg je een tweede cutscene en een triggerpart toe.

  1. Voeg in Workspace, Cutscenes een Folder toe met de naam Bridge en zet de shots ervan neer zoals in stap 1, met de namen 1 en 2. Schrijf in de regel voor de Command Bar Bridge in plaats van Intro.
  2. Ga met je muis over Workspace en voeg een Folder toe met de naam CutsceneTriggers.
  3. Voeg daarin een Part toe met de naam BridgeTrigger. Maak het zo groot dat spelers er niet langs kunnen zonder het aan te raken, bijvoorbeeld een hoge brede plaat dwars over de weg. Vink Anchored aan, vink CanCollide en CanQuery uit, laat CanTouch aangevinkt en zet Transparency op 1. Met CanQuery uit blokkeert de onzichtbare plaat geen raycasts, bijvoorbeeld schoten uit de handleiding over wapens. Aanraakevents worden bestuurd door CanTouch, niet door CanQuery, dus de trigger werkt nog steeds.
  4. Geef hem een attribuut Cutscene van het type string met de waarde Bridge: de naam van de map die moet spelen.

CutsceneService koppelt Touched bij het starten van de server aan elk part dat direct in CutsceneTriggers staat, dus voeg triggers toe in Studio, niet met een script tijdens het spel. Een trigger met CanTouch uit wordt overgeslagen met een waarschuwing in Output, omdat Roblox een fout geeft als een script Touched aan zo'n part koppelt.

Terwijl een personage door het part loopt, gaat Touched vaak achter elkaar af. De tabel seen en de regel "één cutscene tegelijk" maken daar één cutscene per speler per server van. Een speler die de trigger aanraakt tijdens een andere cutscene wordt genegeerd, en de trigger blijft voor hem klaarstaan.

Zet geen triggers op wegen. De HumanoidRootPart van een zittende speler is aan de stoel gelast, en als één part van een gelaste groep geankerd is, ankert Roblox de rest mee. Een speler die de trigger in rijdt, houdt dus zijn hele voertuig vast, met passagiers erbij, tot de cutscene klaar is.

Wat de cameracode goed doet

Scriptable, daarna terug naar Custom

De camerascripts van Roblox bewegen de camera niet en werken hem niet bij zolang CameraType Scriptable is, en precies daardoor kan CutscenePlayer hem neerzetten. Aan het eind zet hij CameraType terug op Custom en maakt hij de Humanoid van de speler de CameraSubject, die de camerascripts van Roblox standaard volgen. Dat gebeurt ook na Skip, dus de speler blijft nooit naar het laatste shot kijken.

Twee kleine controles houden de cutscene de baas zolang hij speelt. Zet iets CameraType midden in de cutscene op een andere waarde, dan zet de functie die elk frame draait hem het volgende frame terug op Scriptable. En workspace.CurrentCamera leest het script aan het begin van elke cutscene opnieuw, omdat Roblox een nieuwe Camera maakt als de huidige ooit verwijderd wordt.

Focus, elk frame

Camera.Focus vertelt de engine welk gebied voorrang krijgt bij werk zoals belichting. De camerascripts van Roblox houden hem op de CameraSubject, maar niet als de camera Scriptable is, en de referentie van Roblox zegt dat je hem in dat geval elk frame moet bijwerken: dynamisch licht van objecten zoals een PointLight wordt ver van de focus misschien niet getekend. CutscenePlayer zet hem 30 studs voor de camera (FOCUS_DISTANCE). Verhoog dat getal als je shots naar iets verder weg kijken.

De functie draait via RunService:BindToRenderStep, elk frame voor het tekenen, één prioriteitsstap na de eigen camera-update van Roblox (Enum.RenderPriority.Camera.Value + 1). Die prioriteit gebruikt de cameratutorial van Roblox, dus de cutscene zet de camera neer nadat de eigen cameracode van Roblox gedraaid heeft.

Vloeiend maken met TweenService:GetValue

Een tween op camera.CFrame zou de camera bewegen, maar Focus moet toch elk frame ingesteld worden, dus CutscenePlayer beweegt de camera zelf in dezelfde functie. Voor elke vlucht berekent hij welk deel van de tijd voorbij is (van 0 tot 1), haalt dat door TweenService:GetValue met een easingstijl en -richting en zet de camera op dat deel van de weg tussen twee shots met CFrame:Lerp, dat de positie in een rechte lijn beweegt en vloeiend draait. GetValue begrenst de invoer tussen 0 en 1, dus de camera stopt precies op het shot als de tijd van de vlucht om is.

Easingstijlen die passen bij een cameravlucht
EASING_STYLEHoe de vlucht aanvoelt
Enum.EasingStyle.Sine (hier)De snelheid volgt een sinus, zachte start en zachte stop.
Enum.EasingStyle.QuadZoals Sine, maar de curve is iets scherper.
Enum.EasingStyle.LinearConstante snelheid, dus elke vlucht begint en eindigt op volle snelheid.

Richting InOut: de easing wordt in de eerste helft van de vlucht vooruit toegepast en in de tweede helft andersom, dus de camera versnelt vanaf het ene shot en remt af naar het volgende.

Streaming

In nieuwe places staat instance streaming aan: standaard houdt het apparaat van de speler het gebied rond zijn personage, dus een shot dat naar de andere kant van de map kijkt, kan een lege wereld laten zien. CutsceneService vraagt Roblox het gebied van elk shot voor deze speler te laden met Player:RequestStreamAroundAsync: het gebied van het eerste shot voordat het event verstuurd wordt, met een wachttijd tot 2 seconden, en dat van elk volgend shot 2 seconden voordat de camera erheen vliegt.

Roblox schrijft dat het gebied zo waarschijnlijk, maar niet zeker, geladen wordt, en dat het effect tijdelijk is. Houd belangrijke shots binnen de streamingradius of gebruik op de server Player:AddReplicationFocus voor een gebied dat geladen moet blijven tot je de focus weghaalt. Met streaming uit heeft het apparaat de hele map al, en de pcall rond elk verzoek betekent dat een mislukt verzoek de cutscene niet kan stoppen.

Wat er mis is in oude cutscenetutorials

Vergelijk je deze handleiding met een video of een forumpost, dan zijn dit de verschillen die ertoe doen, en waarom elke truc een probleem is.

Veelgebruikte trucs in cutscenetutorials en wat deze handleiding in plaats daarvan doet
TutorialProbleemDeze handleiding
Beweegt de camera met camera:Interpolate()Roblox heeft Interpolate als verouderd gemarkeerd en raadt aan de camera met TweenService te animeren.Maakt elke vlucht vloeiend met TweenService:GetValue en zet de camera elk frame neer.
Tweent camera.CFrame en verder nietsFocus blijft waar de camerascripts hem lieten, bij het personage, dus dynamisch licht ver daarvandaan wordt misschien niet getekend (referentie van Roblox over Camera.Focus).Zet Focus elk frame in de render step.
Geeft de camera niet terugDe speler zit vast en kijkt naar het laatste shot.Zet aan het eind CameraType op Custom en CameraSubject op de Humanoid, ook na Skip.
Start de cutscene vanuit Touched in een LocalScriptNiets houdt hem tegen om bij elke aanraking te herhalen, en de beslissing valt op het apparaat dat de speler bestuurt.De server kiest de speler en onthoudt wie hem al gezien heeft.
Leest de cameraparts op de clientMet streaming aan bestaan parts ver van het personage misschien nog niet op het apparaat.De server leest de parts, stuurt hun CFrame en vraagt het gebied van elk shot op kort voordat de camera erheen vliegt.

Wat een speler wel en niet kan veranderen

Ga ervan uit dat een cheater alles op zijn eigen apparaat bestuurt: hij kan CutscenePlayer veranderen of verwijderen en CutsceneEvent met elke waarde versturen. Voor een cutscene betekent dat bijna niets, zolang er niets echts van afhangt.

Wat een cheater kan proberen en wat daarvan komt
De cheater probeertResultaat
De cutscene overslaan of helemaal niet afspelenKan: het is zijn eigen scherm. Geef nooit een beloning voor "cutscene uitgekeken".
CutsceneEvent met elke waarde versturenAlleen een getal dat overeenkomt met zijn huidige cutscene doet iets, en het enige wat het doet is hem eerder ontdooien.
De trigger aanraken vanaf elke plek op de mapMogelijk: elk apparaat bestuurt zijn eigen personage, en de beveiligingsdocumentatie van Roblox noemt het vervalsen van Touched-events bij wat het kan doen. Hij ziet die cutscene één keer, en verder gebeurt er niets.
Toch bewegen tijdens de cutsceneEr valt niets te winnen. Het bevriezen voorkomt dat eerlijke spelers midden in een cutscene weglopen; het is geen beveiligingscontrole.
Via de remote een cutscene starten voor iemand andersOnmogelijk. Alleen de server kan CutsceneEvent naar een speler sturen, en het enige wat een apparaat terug kan sturen is "deze cutscene is klaar".

Leidt de cutscene tot iets echts, bijvoorbeeld een deur die daarna opengaat of een boss die verschijnt, laat de server dat dan op zijn eigen timer doen, niet als het apparaat meldt dat de cutscene klaar is.

Stap 5: Test het

  1. Zet drie shots voor Intro neer met de regel voor de Command Bar. Geef shot 1 de Caption "Welcome to the village", shot 2 MoveSeconds 2.5 en de Caption "Find the bridge", en laat shot 3 zonder attributen.
  2. Klik op Play (F5). De zwarte balken verschijnen, de camera springt naar shot 1 met zijn ondertitel, vliegt in 2.5 seconden naar shot 2 en dan in 3 seconden naar shot 3 zonder ondertitel. Daarna gaat de camera terug achter het personage en komt de spelerslijst weer tevoorschijn. Zolang hij speelt, kun je niet lopen.
  3. Stop de test, klik opnieuw op Play en klik op Skip terwijl de camera naar shot 2 vliegt. De camera komt meteen terug en je kunt meteen lopen.
  4. Loop BridgeTrigger in: de cutscene Bridge speelt. Loop er nog een keer doorheen: er gebeurt niets.
  5. Kies Server & Clients in de keuzelijst van de testmodus, zet 2 clients en klik op Play. Als Client 1 de trigger in loopt, speelt de cutscene Bridge alleen bij Client 1, en Client 2 kan lopen.
  6. Laat Workspace.StreamingEnabled aan staan en zet één shot ver van de spawn. Als de camera aankomt, moet de omgeving er zijn (waarschijnlijk, maar niet gegarandeerd: zie Streaming).
  7. Voor een gamepad stop je de test, klik je op Play, open je de Controller Emulator (tabblad Emulation, dan Controller) en loop je BridgeTrigger in met de geëmuleerde gamepad: Skip moet geselecteerd zijn, dus A slaat de cutscene over. Gebruik je de Device Simulator in Studio (toen wij het op 15 oktober 2026 controleerden een bèta: zet hem aan via File, Beta Features, New Device Simulator en start Studio opnieuw), kies dan een telefoon, draai hem horizontaal en controleer dat Skip niet onder de camera-uitsparing komt en makkelijk te raken is, en dat de joystick en de springknop verborgen zijn zolang de cutscene loopt.
  8. Heb je ook een hoofdmenu gemaakt, klik dan op Play, daarna op de knop Play in het menu en laat de intro helemaal uitspelen: daarna moet de spelerslijst weer op het scherm staan.

Houd het venster Output de hele tijd open (menu Window, dan Output). Als alles werkt, schrijven deze scripts niets, dus elke waarschuwing of rode fout van CutsceneService of CutscenePlayer is een echt probleem. Zie Veelvoorkomende fouten.

Het systeem uitbreiden

De intro alleen bij de eerste keer joinen

De tabel seen leeft één server lang, dus een speler die opnieuw joint, ziet de intro weer. Wil je hem alleen bij de eerste keer joinen laten zien, sla dan een vlag op, bijvoorbeeld SeenIntro, samen met de andere data van de speler via de module PlayerData uit de DataStore-tutorial. Laat INTRO_CUTSCENE zoals hij is en verander het deel van onCharacterAdded in CutsceneService dat de intro regelt: wacht tot PlayerData.Get(player) de data van de speler teruggeeft, sla de intro over als data.SeenIntro true is, en zet data.SeenIntro = true alleen als playOnce(player, INTRO_CUTSCENE) true teruggaf. Start de intro niet vanuit de code die de data laadt: de data kan geladen zijn voordat het personage spawnt, en zonder personage doet play niets, en dan wordt de vlag opgeslagen voor een intro die niemand zag.

Personages die meespelen in de cutscene

Maak een animatie in de Animation Editor in Studio of in een animatieplugin van derden, zoals Moon Animator, die in de documentatie van Roblox genoemd wordt, en speel hem af op een NPC-rig in het shot als de camera daar aankomt. De referentie van Roblox over Animator zegt dat animaties van NPC's alleen repliceren als de server ze laadt en start, dus speel hem af vanuit een server-Script als alle spelers de NPC moeten zien spelen. Laad en start je hem in CutscenePlayer, dan repliceert de animatie niet, en dat past bij een cutscene die maar één speler bekijkt. De handleiding over animatiescripts laat zien hoe je een animatie op een NPC afspeelt vanuit een server-Script.

Dialogen

Ondertitels passen bij korte zinnen die vanzelf doorlopen. Voor een gesprek waarin de speler antwoordt en opties kiest, zie de handleiding over dialogen met NPC's.

De intro na het hoofdmenu

De handleiding over het hoofdmenu zet CharacterAutoLoads uit, dus niemand spawnt voordat hij op Play klikt. CutsceneService speelt de intro bij de eerste spawn van de speler, dus met beide systemen speelt de intro bij de eerste spawn na Play. Het menu zet de core GUI weer aan als het personage verschijnt, en dat kan gebeuren terwijl de intro al speelt, dus tijdens de intro kan de spelerslijst zichtbaar zijn. CutscenePlayer zet alleen terug aan wat hij zelf verborg, dus de wijziging van het menu raakt hij niet aan, en na de intro blijven ze aan. De truc met de Command Bar uit de handleiding over het hoofdmenu om een camerapart te richten is dezelfde als in stap 1.

Een vlucht over de map aan het begin van een ronde

Om een cutscene te starten vanuit een ander serverscript, bijvoorbeeld een vlucht over de map aan het begin van een ronde uit de handleiding over het rondesysteem, voeg je in ServerStorage een BindableEvent toe met de naam PlayCutscene. Koppel aan het eind van CutsceneService zijn Event aan de functie play, en laat het rondescript hem aanroepen met elke speler en de naam van de cutscene. play slaat de controle "één keer per server" over, dus de vlucht speelt elke ronde.

Plugins voor cutscenes

Je kunt plugins samen met deze handleiding gebruiken. Schrijft een cutsceneplugin zijn eigen camerascript, controleer dan dat hij de camera teruggeeft (CameraType Custom en CameraSubject) en Focus instelt zolang de camera Scriptable is, en laat de beslissing wie de cutscene ziet bij de server, zoals in deze handleiding.

Veelvoorkomende fouten en oplossingen

Open het venster Output (menu Window, dan Output) voordat je op Play klikt. De meeste problemen met cutscenes schrijven daar een waarschuwing of komen door een naam die niet klopt.

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

CutsceneService wacht op een map met de naam Cutscenes direct in Workspace. Maak hem zoals in stap 1 en controleer de spelling en de hoofdletter C. Zolang hij er niet is, maakt CutsceneService geen CutsceneEvent, dus CutscenePlayer wacht ook.

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

CutscenePlayer wacht op de remote die CutsceneService maakt. Controleer dat CutsceneService een Script is en geen LocalScript, direct in ServerScriptService staat, niet uitgeschakeld is en dat er in Output geen fout of waarschuwing over Cutscenes van komt.

CutsceneService: no folder named Intro in Workspace.Cutscenes

De naam in INTRO_CUTSCENE of in het attribuut Cutscene van de trigger komt met geen enkele map in Workspace.Cutscenes overeen. Hoofdletters in de namen tellen mee.

Er speelt niets en Output is leeg

In de map staat geen part met de naam 1, of de parts staan er niet direct in (bijvoorbeeld binnen een Model). CutsceneService leest de parts 1, 2, 3 op volgorde en stopt bij het eerste ontbrekende nummer. En onthoud dat elke cutscene één keer per speler per server speelt: stop de test en klik opnieuw op Play.

De camera kijkt de verkeerde kant op

De camera kijkt dezelfde kant op als de voorkant van het shotpart. Beweeg de Studio-camera naar het beeld dat je wilt en voer de regel voor de Command Bar uit stap 1 opnieuw uit voor dat shot.

De trigger doet niets

Controleer dat het triggerpart direct in Workspace.CutsceneTriggers staat als de game start, dat CanTouch aangevinkt is (anders staat er een waarschuwing in Output) en dat zijn attribuut Cutscene een string is met de naam van een map in Workspace.Cutscenes. Nog een keer door de trigger lopen doet niets, dat is zo bedoeld.

Na de cutscene blijft de camera op het laatste shot

CutscenePlayer stopte met een fout voordat hij de camera kon teruggeven, dus zoek een rode fout van hem in Output. De camera kan ook vastgehouden worden door een ander script dat CameraType steeds op Scriptable zet, bijvoorbeeld een menucamera die nog gekoppeld is.

Maak het met RoCode

Heb je geen zin om dit met de hand te bouwen, dan kan RoCode het maken in de place die je open hebt. RoCode is een onafhankelijke AI-agent voor Roblox Studio, niet van Roblox: je beschrijft de functie in de webchat en de plugin voor Studio maakt het part en de scripts in je Explorer, dus je hoeft geen code uit een chatvenster te kopiëren.

Jij typt

Voeg een introcutscene toe: een map Cutscenes met een map Intro en shots 1 tot en met 3, ondertitels uit het attribuut Caption, zwarte balken en een knop Skip, speelt één keer bij de eerste spawn van de speler, de server houdt de speler op zijn plek en aan het eind komt de camera terug.

RoCode doet
  • Kan eerst je place doorzoeken met Search Scripts, bijvoorbeeld op een menu- of camerascript dat al CameraType instelt, zodat ze niet botsen
  • Maakt de mappen en het triggerpart via Create Instance en zet attributen zoals Caption en MoveSeconds op de parts
  • Schrijft CutsceneService en CutscenePlayer via Create Script
  • Heeft de opdracht elk geschreven script te controleren met Check Script, dat het in Studio compileert zonder het uit te voeren, en zet een ongedaanmaakpunt voor en na elke groep wijzigingen

Zet de shotparts zelf neer door de Studio-camera naar elk beeld te bewegen, en vraag daarna om de scripts. Met plugin 3.9 of nieuwer kan RoCode een korte playtest starten en de fouten lezen, en met plugin 3.9.11 of nieuwer kan hij een testpersonage besturen om te controleren dat de game werkt, maar tijdens het spelen maakt hij geen screenshots, dus de cutscene bekijk je zelf. De volgorde om een hele game te bouwen staat op de pagina hoe je een game in Roblox maakt met AI, systeem voor systeem. Hoe RoCode verbinding maakt met Studio.

Veelgestelde vragen

Hoe laat je een cutscene spelen als iemand de game joint?

Noem de map met shots Intro in Workspace.Cutscenes of verander INTRO_CUTSCENE in de naam van je map. CutsceneService speelt hem bij de eerste spawn van elke speler op de server. Wil je hem alleen bij de allereerste keer joinen laten zien, sla dan een vlag op in een data store en zet die pas nadat de intro begonnen is, zoals beschreven in Het systeem uitbreiden.

Kun je een cutscene maken zonder plugins?

Ja. Deze handleiding gebruikt alleen parts, attributen en twee scripts, en de regel voor de Command Bar zet elk shot precies waar de Studio-camera staat. Plugins zoals Moon Animator blijven handig om de personages te animeren die in de cutscene meespelen.

Waarom beweegt de camera niet in mijn cutscene?

Meestal staat de cameracode in een server-Script, terwijl alleen een LocalScript de camera van een speler kan bewegen, omdat elk apparaat zijn eigen camera heeft. Een andere veelvoorkomende oorzaak: CameraType is niet Scriptable, en de standaard camerascripts van Roblox zetten de camera steeds terug bij het personage.

Hoe voorkom je dat een speler beweegt tijdens een cutscene?

Anker zijn HumanoidRootPart op de server zolang hij speelt en haal het anker daarna weg, zoals CutsceneService doet. Een geankerd part beweegt nooit door fysica. WalkSpeed wordt daarbij niet aangeraakt, dus het botst niet met een sprintscript of een speedpass.

Hoe voeg je een knop Skip toe aan een cutscene?

Zet een TextButton op het cutscenescherm en koppel zijn event Activated, dat afgaat bij een klik, een tik of de knop A op een gamepad als de knop geselecteerd is. Skip in CutscenePlayer zet een vlag die de lus van de shots elk frame controleert, selecteert zichzelf voor gamepadspelers en staat in een eigen ScreenGui met de standaardmarges, zodat de camera-uitsparing van een telefoon hem niet bedekt. De joystick en de springknop zijn verborgen zolang de cutscene loopt, dus ze staan er niet naast.

Waarom is de wereld leeg in mijn cutscene?

Met instance streaming aan heeft het apparaat van de speler alleen het gebied in de buurt van zijn personage. Laat de server voor elk shot player:RequestStreamAroundAsync aanroepen kort voordat de camera erheen vliegt, zoals CutsceneService doet. Roblox schrijft dat het gebied zo waarschijnlijk, maar niet zeker, geladen wordt, dus houd belangrijke shots binnen de streamingradius of gebruik Player:AddReplicationFocus voor een gebied dat geladen moet blijven.

Bronnen en verder lezen

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

Probeer RoCode in je eigen game.

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