Tutorial · Spilsystemer

Sådan laver du en cutscene i Roblox Studio

En cutscene i Roblox er et kamera, der tager styringen i nogle sekunder: skifter eller glider mellem billeder, viser en undertekst og giver styringen tilbage til spilleren. I denne guide bygger vi en cutscene, som du sætter op ved at placere usynlige parts der, hvor kameraet skal stå, uden plugins. Serveren afgør, hvornår spilleren ser den (ved første spawn eller ved berøring af en trigger), og spillerens enhed flytter kameraet, viser sorte bjælker og en Skip-knap og giver kameraet tilbage.

Opdateret 20. november 202622 min. læsningSkrevet af

Kort fortalt

Placér usynlige ankrede parts med navnene 1, 2, 3 i en mappe inde i Workspace.Cutscenes, hver med forsiden derhen, hvor kameraet skal kigge. Et Script i ServerScriptService læser deres CFrame, holder spilleren på stedet og sender billederne til den spiller via en RemoteEvent. Et LocalScript i StarterPlayerScripts sætter workspace.CurrentCamera.CameraType til Scriptable, flytter hvert frame kameraet fra billede til billede (udglattet med TweenService:GetValue) og sætter derefter CameraType tilbage til Custom og CameraSubject til spillerens Humanoid.

  • Kun spillerens enhed kan styre kameraet, så kamerakoden er et LocalScript. Serveren afgør kun, hvem der ser hvilken cutscene og hvornår.
  • Når kameraet er Scriptable, holder Roblox op med at opdatere Camera.Focus. Referencen siger, at du skal opdatere Focus hvert frame, ellers bliver dynamisk lys langt fra det gamle fokus måske ikke tegnet.
  • Camera:Interpolate er forældet. Roblox-referencen siger, at du skal animere kameraet med TweenService.
På denne side
  1. Sådan virker det
  2. 1. Billeder
  3. 2. Server-script
  4. 3. LocalScript
  5. 4. Trigger
  6. Kameradetaljer
  7. Gamle tutorials
  8. Beskyttelse mod snyd
  9. 5. Test
  10. Udvidelse
  11. Common errors
  12. Med RoCode
  13. Ofte stillede spørgsmål
  14. Kilder og videre læsning

Sådan virker en cutscene

IllustrationEn intro med to billeder i virkelig hastighed: skift til første billede, pause på 1 sekund, kameratur til broen på 2.5 sekunder, pause på 1 sekund, og derefter vender kameraet tilbage til spilleren.

Hver spillers enhed har sit eget Camera-objekt i workspace.CurrentCamera, så kun et LocalScript kan flytte det, spilleren ser. At afgøre, hvem der ser hvilken cutscene og hvornår, er serverens job. Guiden deler arbejdet præcis sådan. En cutscene forløber sådan:

  1. Serveren afgør, at spilleren skal se en cutscene: Intro ved første spawn på serveren eller en anden, når spilleren rører en trigger-part.
  2. CutsceneService læser billed-parternes CFrame og indstillinger, beder Roblox streame området omkring det første billede til spilleren, ankrer spillerens HumanoidRootPart, så spilleren står stille, og sender CutsceneEvent kun til den spiller med et id og en liste over billeder.
  3. CutscenePlayer på spillerens enhed viser sorte bjælker og en Skip-knap, skjuler spillerlisten, rygsækken, livbjælken og touchstyringen, gør kameraet Scriptable og flytter det hvert frame.
  4. Når det sidste billede er slut, eller spilleren trykker på Skip, giver den kameraet tilbage til karakteren og sender CutsceneEvent med det samme id til serveren.
  5. Serveren fjerner ankringen fra spilleren. Hvis den besked aldrig kom, fjerner den alligevel ankringen, når cutscenens længde plus 2 sekunder er gået. Timeren starter, når serveren sender cutscenen, og ved en langsom indgang kan enheden starte introen et par sekunder senere, fordi et LocalScript uden for ReplicatedFirst ikke starter, før spillet er indlæst. Så kan spilleren bevæge sig igen, før introen er slut på spillerens skærm.
Hvad cutscene-systemet består af
ElementHvor det liggerHvad det gør
Script CutsceneServiceServerScriptServiceAfgør, hvem der ser hvilken cutscene og hvornår, læser billederne, holder spilleren på stedet og husker, hvem der allerede har set hvad.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsAfspiller cutscenen på spillerens skærm: bjælker, undertekster, Skip og kamerabevægelse. Til sidst giver den kameraet tilbage.
RemoteEvent CutsceneEventReplicatedStorage (oprettes af CutsceneService)Bærer billederne fra serveren til én spiller og beskeden "cutscenen er slut" tilbage.
Folder CutscenesWorkspaceÉn mappe pr. cutscene, for eksempel Intro, med billed-parts 1, 2, 3.
Folder CutsceneTriggersWorkspace (valgfrit)Parts, der starter en cutscene, når en spiller rører dem.
Explorer, når cutscene-systemet er færdigt. Mapperne Bridge og CutsceneTriggers dukker op i trin 4. Når spillet starter, tilføjer CutsceneService en RemoteEvent med navnet CutsceneEvent i 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

Trin 1: placér kamerabillederne

Hvert billede er en usynlig part. Kameraet tager partens position og kigger samme vej som dens forside, så at placere et billede er at placere kameraet.

  1. I Explorer holder du musen over Workspace, klikker på knappen + og indsætter en Folder med navnet Cutscenes. Indsæt inde i den en Folder med navnet Intro. Store og små bogstaver i navnene betyder noget.
  2. Flyt Studio-kameraet hen til den første udsigt, du vil have, som om du komponerede et foto.
  3. Indsæt en Part i Intro, og omdøb den til 1.
  4. Åbn Command Bar (på fanen Script eller via Window, derefter Script), og kør workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. I redigeringstilstand er CurrentCamera den udsigt, du kigger igennem, så parten sættes præcis i det billede. Firkantede parenteser og anførselstegn er nødvendige, fordi et navn, der starter med et tal, ikke kan skrives efter et punktum.
  5. I partens Properties sætter du flueben i Anchored, fjerner flueben i CanCollide, CanTouch og CanQuery og sætter Transparency til 1. Anchored forhindrer den i at falde gennem kortet; resten forhindrer den i at stå i vejen for spillere, udløse berøringsevents og blokere raycasts.
  6. Gentag for de næste udsigter, kald parterne 2, 3 og så videre, og ændr nummeret i Command Bar-linjen. CutsceneService afspiller billederne i nummerrækkefølge og stopper ved det første manglende nummer, så et hul i nummereringen afbryder cutscenen for tidligt.

For senere at ændre et billede flytter du kameraet hen til den nye udsigt og kører den samme linje med det billedes nummer. Med Transparency 1 er parterne også usynlige i Studio, så vælg dem i Explorer, når du har brug for dem.

Hvert billede kan have tre valgfrie attributter mere. For at tilføje en attribut vælger du parten, ruller Properties-vinduet ned til afsnittet Attributes, klikker på +, skriver navnet, vælger typen og klikker på Save.

Valgfrie attributter på hver billed-part
AttributTypeStandardHvad den gør
MoveSecondsnumber3Hvor mange sekunder kameraet flyver fra det forrige billede til dette. 0 giver et hårdt skift. Billede 1 er altid et skift, så attributten virker ikke for det.
HoldSecondsnumber1Hvor mange sekunder kameraet står på dette billede efter ankomst.
CaptionstringingenTekst på den nederste bjælke fra det øjeblik, kameraet begynder at flyve mod dette billede. Et billede uden Caption rydder teksten.

Et tal under 0 eller over 60 og en attribut af forkert type erstattes af standardværdien.

Trin 2: tilføj server-scriptet

Hold musen over ServerScriptService, indsæt et Script med navnet CutsceneService, og indsæt koden nedenfor i det. Indstillingerne øverst er de linjer, du kan ændre.

Script i ServerScriptService med navnet CutsceneService
-- Script i ServerScriptService med navnet CutsceneService.
-- Afgør, hvem der ser hvilken cutscene og hvornår. Læser kamerabillederne fra nummererede
-- parts i Workspace.Cutscenes, holder spilleren på stedet og beder den spillers enhed
-- afspille billederne. Selve kameraet kan kun flyttes på enheden.

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

-- Indstillinger
local INTRO_CUTSCENE = "Intro" -- afspilles én gang ved spillerens første spawn; "" for at slå fra
local DEFAULT_MOVE_SECONDS = 3 -- flyvetid til et billede, hvis det ikke har MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- tid på et billede, hvis det ikke har HoldSeconds
local MAX_SHOTS = 30

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

-- Dette script opretter selv CutsceneEvent, så tilføj den ikke i hånden
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 på den cutscene, spilleren ser
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

-- Billederne er parts 1, 2, 3 ... i mappen med cutscenens navn
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,
			-- det første billede er et skift, så kameraet springer straks derhen
			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 -- denne cutscene er allerede slut
	end
	playing[player] = nil
	setFrozen(player, false)
end

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

	-- Med instance streaming har spillerens enhed måske ikke det område,
	-- et billede kigger på, og forespørgslen indlæser kun området midlertidigt. Indlæs
	-- det første billedes område nu (vent op til 2 sekunder) og hvert følgende billedes
	-- 2 sekunder før kameraet flyver derhen.
	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 -- spilleren gik, mens området blev indlæst
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- sekunder fra nu til flyveturen mod dette billede starter
	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
	-- Sikkerhedsnet: frigør spilleren, selv hvis spillerens enhed aldrig svarede
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Returnerer kun true, hvis cutscenen startede for denne spiller
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

-- Spillerens enhed melder, at cutscenen er slut eller sprunget over
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Trigger-parts: berøring starter cutscenen fra deres attribut Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- At forbinde Touched til en part med CanTouch slået fra giver en fejl, så vi advarer bare
			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 under en cutscene, hold også den nye karakter på stedet
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- allerede sat op
	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, der kom ind, mens scriptet ventede på Cutscenes
	onPlayerAdded(player)
end

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

CutsceneService opretter selv RemoteEvent CutsceneEvent, så snart Workspace.Cutscenes dukker op, så du behøver ikke at indsætte noget i ReplicatedStorage i hånden. Hvis du allerede har lavet en RemoteEvent med det navn, så slet den: LocalScriptet kan finde din, og den lytter ingen på serveren efter.

Indstillingerne øverst i CutsceneService
IndstillingVærdi herHvad den ændrer
INTRO_CUTSCENE"Intro"Den mappe i Workspace.Cutscenes, der afspilles ved spillerens første spawn på serveren. Sæt "", hvis der ikke skal være en intro.
DEFAULT_MOVE_SECONDS3Hvor længe en flyvetur varer, hvis billedet ikke har attributten MoveSeconds.
DEFAULT_HOLD_SECONDS1Hvor længe kameraet står på et billede, hvis det ikke har attributten HoldSeconds.
MAX_SHOTS30Det højeste billednummer, CutsceneService leder efter i én cutscene.

Hvad resten af scriptet gør, i rækkefølge:

  • Læser billederne på serveren. readShots samler hver nummereret parts CFrame og attributter i en liste. Spillerens enhed får den liste, så den behøver ikke selve parterne.
  • Én cutscene ad gangen. play gør ingenting, mens spilleren allerede ser en cutscene, eller hvis spillerens karakter ikke har en Humanoid eller er død.
  • Hver cutscene har sit eget id. Enheden sender id'et tilbage, når cutscenen slutter eller springes over, og kun et matchende id frigør spilleren, så en forsinket besked fra en tidligere cutscene kan ikke afslutte en ny.
  • Holder spilleren på stedet ved at ankre spillerens HumanoidRootPart, og ankrer den nye karakter, hvis spilleren respawner midt i en cutscene. Roblox-referencen siger, at en ankret part aldrig ændrer position på grund af tyngdekraft, kollisioner eller anden fysik. WalkSpeed røres ikke, så det konflikter ikke med et sprint-script eller et speed-pass. Til sidst fjerner scriptet ankringen fra root part, selv hvis et andet script ankrede den, så ankr ikke karakterer andre steder, mens en cutscene kan køre.
  • Sikkerhedsnet. task.delay frigør spilleren efter cutscenens fulde længde plus 2 sekunder, selv hvis spillerens enhed aldrig svarede.
  • Hver cutscene én gang pr. server. Tabellen seen husker for hver spiller, hvilke cutscenes der allerede er startet, så introen gentages ikke ved respawn, og en cutscene fra en trigger afspilles én gang. playOnce returnerer kun true, hvis cutscenen faktisk startede.
  • Sætter hver spiller op. Løkken over Players:GetPlayers() til sidst fanger alle, der kom ind, mens scriptet ventede på mappen Cutscenes.

Billederne sendes til spilleren med ét FireClient-kald som en liste af små tabeller. Robloxs side om remote events siger, at man ikke skal sende en tabel, hvor tal- og strengnøgler er blandet; denne liste har kun talnøgler, og hvert billede indeni kun strengnøgler, hvilket er den form, siden anbefaler.

Trin 3: tilføj LocalScriptet, der afspiller den

  1. I Explorer folder du StarterPlayer ud, holder musen over StarterPlayerScripts og indsætter et LocalScript med navnet CutscenePlayer.
  2. Erstat indholdet med koden nedenfor.
LocalScript i StarterPlayerScripts med navnet CutscenePlayer
-- LocalScript i StarterPlayer > StarterPlayerScripts med navnet CutscenePlayer.
-- Afspiller den cutscene, serveren sender: sorte bjælker, undertekster, en Skip-knap og et
-- kamera, der flyver fra billede til billede. Giver derefter kameraet tilbage til spilleren.

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 -- hver sort bjælke, som andel af skærmens højde
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- hvor mange studs foran kameraet Roblox skal tegne mest detaljeret
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 }

-- Cutscene-skærmen: to sorte bjælker og en undertekst, fra kant til kant. Roblox anbefaler kun
-- ScreenInsets None til ting, ingen trykker på, så Skip nedenfor har sin egen ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- hele skærmen
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

-- Skip-knappen har standardmargener, så kameraets udskæring ikke dækker den
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) -- på den nederste bjælke, til højre
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 forbliver stor nok til at ramme på en lille telefon
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

-- Den nuværende flyvetur: fra én kamera-CFrame til den næste på et givet antal sekunder
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Kører hvert frame under cutscenen. Focus på et Scriptable-kamera følger ikke selv efter
-- noget, så det sættes også her.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- noget nulstillede det, for eksempel en 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
		-- En kører allerede, så lad serveren straks frigøre spilleren for denne
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Skjul spillerlisten, rygsækken og livbjælken, og husk, hvad der var synligt
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- På telefoner skjules sticken og hopknappen, der står i de nederste hjørner
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- En gamepad kan kun trykke på den valgte knap, så for spillere med gamepad vælger vi Skip
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Ét trin efter Robloxs egen kameraopdatering, som i Robloxs kamera-tutorial
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- hver flyvetur starter, hvor kameraet er nu
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- Giv kameraet tilbage til spillerens karakter
	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 = ""
	-- Slå kun det til igen, som denne cutscene slog fra, og rør ikke resten
	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) -- serveren frigør straks spilleren
	busy = false
end

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

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

Et LocalScript i StarterPlayerScripts kopieres til spilleren én gang, ved indgang, og bliver ved med at køre efter karakterens respawn. Derfor har begge ScreenGuis ResetOnSpawn slået fra: hvis du slår det til, sletter Roblox dem ved første respawn, og dette script opretter dem ikke igen. Remote-beskeder, der kom, før scriptet forbandt til OnClientEvent, sættes i kø og leveres efter forbindelsen, så en spiller, der spawnede hurtigt, stadig ser introen.

Hvad hver del af CutscenePlayer gør
DelHvad den gør
ScreenGui CutsceneTo sorte bjælker, hver på 12% af skærmens højde (BAR_HEIGHT), og en undertekst på den nederste bjælke. ScreenInsets None strækker bjælkerne helt ud til skærmens kanter, og DisplayOrder 10 tegner dem oven på ScreenGuis med lavere DisplayOrder.
ScreenGui CutsceneControlsIndeholder kun Skip-knappen, til højre på den nederste bjælke, med en UISizeConstraint, der holder den på mindst 64 gange 32 pixels, så den er nem at ramme på en telefon. Den har standard-ScreenInsets, og indholdet går ikke ind under Robloxs knapper i topbjælken og kameraudskæringer. Roblox anbefaler kun None til indhold, der ikke skal trykkes på, så Skip kan ikke ligge i ScreenGui med bjælkerne.
HIDDEN_CORE_GUISSkjuler spillerlisten, rygsækken og livbjælken med SetCoreGuiEnabled efter først at have husket med GetCoreGuiEnabled, hvilke der var slået til, og slår til sidst kun dem til igen, som den selv slog fra. Hvis spillet skjuler rygsækken et andet sted, forbliver den skjult, og et script, der slår dem til under cutscenen, for eksempel en hovedmenu, bliver ikke overtrumfet.
TouchControlsEnabledPå telefoner og tablets sætter play GuiService.TouchControlsEnabled til false under cutscenen. Det skjuler sticken og hopknappen, der står i de nederste hjørner, samme sted som Skip, og til sidst kommer de tilbage, hvis de var slået til.
updateCameraKører hvert frame, mens cutscenen kører. Beregner, hvor stor en del af den nuværende flyvetur der er gået, udglatter den med TweenService:GetValue, sætter kameraet mellem to billeder med CFrame:Lerp og sætter Focus 30 studs foran kameraet.
waitOrSkipVenter på billedets flyvetid og pause og tjekker Skip-flaget hvert frame.
playGør kameraet Scriptable, afspiller billederne i rækkefølge, giver derefter kameraet tilbage (CameraType Custom, CameraSubject er Humanoid), slår core GUI og touchstyring til igen og sender cutscenens id til serveren. Hvis en anden cutscene kommer, mens den første stadig kører, sender den straks dens id tilbage, så serveren ikke holder spilleren på stedet for en cutscene, denne enhed ikke viste.
Skip-knappenActivated udløses ved museklik, tryk eller knappen A på en gamepad, når knappen er valgt. For en spiller, hvis primære input er en gamepad, vælger play Skip i starten af cutscenen og fjerner valget til sidst.

Ændr BAR_HEIGHT for at gøre bjælkerne tyndere eller tykkere og EASING_STYLE for at ændre følelsen af kameraturene (se Hvad kamerakoden gør rigtigt). Underteksten og Skip-knappen har TextScaled slået til, så teksten vokser og skrumper med skærmen.

Trin 4: en cutscene ved berøring af en part

Introen afspilles af sig selv. Til en cutscene et bestemt sted på kortet, for eksempel når spilleren første gang når broen, tilføjer du en anden cutscene og en trigger-part.

  1. I Workspace, Cutscenes indsætter du en Folder med navnet Bridge og placerer dens billeder som i trin 1 med navnene 1 og 2. I Command Bar-linjen skriver du Bridge i stedet for Intro.
  2. Hold musen over Workspace, og indsæt en Folder med navnet CutsceneTriggers.
  3. Indsæt en Part med navnet BridgeTrigger i den. Gør den så stor, at spillerne ikke kan gå forbi uden at røre den, for eksempel en høj, bred plade på tværs af vejen. Sæt flueben i Anchored, fjern flueben i CanCollide og CanQuery, lad CanTouch være sat, og sæt Transparency til 1. Når CanQuery er slået fra, blokerer den usynlige plade ikke raycasts, for eksempel skud fra våben-guiden. Berøringsevents styres af CanTouch, ikke CanQuery, så triggeren virker stadig.
  4. Giv den en attribut Cutscene af typen string, og sæt værdien til Bridge: navnet på den mappe, der skal afspilles.

CutsceneService forbinder Touched til hver part direkte inde i CutsceneTriggers, når serveren starter, så tilføj triggere i Studio og ikke med et script under spillet. En trigger med CanTouch slået fra springes over med en advarsel i Output, fordi Roblox giver en fejl, når et script forbinder Touched til sådan en part.

Mens karakteren går gennem parten, udløses Touched mange gange i træk. Tabellen seen og reglen "én cutscene ad gangen" gør det til én cutscene pr. spiller pr. server. En spiller, der rører triggeren under en anden cutscene, ignoreres, og triggeren forbliver klar til den spiller.

Sæt ikke triggere på veje. En siddende spillers HumanoidRootPart er svejset til sædet, og når én part i en svejset gruppe er ankret, ankrer Roblox resten med den. Derfor holder en spiller, der kører ind i en trigger, hele sit køretøj på stedet, inklusive passagerer, indtil cutscenen er slut.

Hvad kamerakoden gør rigtigt

Scriptable, så tilbage til Custom

Robloxs kamera-scripts flytter og opdaterer ikke kameraet, så længe CameraType er Scriptable, og det er netop det, der lader CutscenePlayer placere det. Til sidst sætter den CameraType tilbage til Custom og gør spillerens Humanoid til CameraSubject, som Robloxs kamera-scripts som standard følger. Det sker også efter Skip, så spilleren bliver aldrig stående og kigge på det sidste billede.

To små tjek holder cutscenen i kontrol, mens den kører. Hvis noget sætter CameraType til en anden værdi midt i cutscenen, sætter funktionen, der kører hvert frame, Scriptable igen i næste frame. Og workspace.CurrentCamera læser scriptet igen i starten af hver cutscene, fordi Roblox opretter et nyt Camera, hvis det nuværende nogensinde slettes.

Focus, hvert frame

Camera.Focus fortæller motoren, hvilket område der skal prioriteres i arbejde som lys. Robloxs kamera-scripts holder det på CameraSubject, men ikke når kameraet er Scriptable, og Roblox-referencen siger, at det i så fald skal opdateres hvert frame: dynamisk lys fra objekter som PointLight bliver måske ikke tegnet langt fra fokus. CutscenePlayer sætter det 30 studs foran kameraet (FOCUS_DISTANCE). Hæv tallet, hvis dine billeder kigger på noget, der er længere væk.

Funktionen kører via RunService:BindToRenderStep, hvert frame før tegningen, ét prioritetstrin efter Robloxs egen kameraopdatering (Enum.RenderPriority.Camera.Value + 1). Den prioritet bruger Robloxs kamera-tutorial, så cutscenen placerer kameraet, efter at Robloxs egen kamerakode har kørt.

Udglatning med TweenService:GetValue

En tween på camera.CFrame ville flytte kameraet, men Focus skal alligevel sættes hvert frame, så CutscenePlayer flytter selv kameraet i den samme funktion. For hver flyvetur beregner den, hvor stor en andel af tiden der er gået (fra 0 til 1), sender den gennem TweenService:GetValue med en udglatningsstil og -retning og sætter kameraet den andel af vejen mellem to billeder med CFrame:Lerp, som flytter positionen i en lige linje og drejer jævnt. GetValue begrænser input til mellem 0 og 1, så kameraet stopper præcis på billedet, når flyvetiden er slut.

Udglatningsstile, der passer til en kameratur
EASING_STYLEHvordan kameraturen føles
Enum.EasingStyle.Sine (her)Hastigheden følger en sinuskurve, blød start og blødt stop.
Enum.EasingStyle.QuadSom Sine, men kurven er lidt skarpere.
Enum.EasingStyle.LinearKonstant hastighed, så hver kameratur starter og slutter i fuld fart.

Retningen InOut: udglatningen anvendes fremad i første halvdel af kameraturen og omvendt i anden halvdel, så kameraet accelererer væk fra ét billede og sætter farten ned mod det næste.

Streaming

I nye places er instance streaming slået til: som standard holder spillerens enhed området omkring sin karakter, så et billede, der kigger på den anden ende af kortet, kan vise en tom verden. CutsceneService beder Roblox streame området omkring hvert billede til spilleren med Player:RequestStreamAroundAsync: det første billedes område før eventet sendes, med op til 2 sekunders ventetid, og hvert følgende billedes område 2 sekunder før kameraet flyver derhen.

Roblox skriver, at området så sandsynligvis, men ikke sikkert, bliver indlæst, og at effekten er midlertidig. Hold vigtige billeder inden for streaming-radius, eller brug Player:AddReplicationFocus på serveren til et område, der skal forblive indlæst, indtil du fjerner fokus. Med streaming slået fra har enheden allerede hele kortet, og pcall omkring hver forespørgsel betyder, at en mislykket forespørgsel ikke kan stoppe cutscenen.

Hvad der er galt i gamle cutscene-tutorials

Hvis du sammenligner denne guide med en video eller et forumindlæg, er her de forskelle, der betyder noget, og hvorfor hvert trick er et problem.

Almindelige tricks i cutscene-tutorials, og hvad denne guide gør i stedet
TutorialProblemDenne guide
Flytter kameraet med camera:Interpolate()Roblox har markeret Interpolate som forældet og anbefaler at animere kameraet med TweenService.Udglatter hver kameratur med TweenService:GetValue og placerer kameraet hvert frame.
Tweener camera.CFrame og intet andetFocus bliver, hvor kamera-scripts lod det være, nær karakteren, så dynamisk lys langt fra det bliver måske ikke tegnet (Roblox-referencen for Camera.Focus).Sætter Focus hvert frame i render step.
Giver ikke kameraet tilbageSpilleren sidder fast og kigger på det sidste billede.Sætter til sidst CameraType til Custom og CameraSubject til Humanoid, også efter Skip.
Starter cutscenen fra Touched i et LocalScriptIntet forhindrer den i at gentage sig ved hver berøring, og beslutningen træffes på den enhed, spilleren styrer.Serveren vælger spilleren og husker, hvem der allerede har set den.
Læser kamera-parts på klientenMed streaming slået til findes parts langt fra karakteren måske endnu ikke på enheden.Serveren læser parterne, sender deres CFrame og beder om hvert billedes område kort før kameraet flyver derhen.

Hvad en spiller kan og ikke kan ændre

Gå ud fra, at en snyder styrer alt på sin egen enhed: den kan ændre eller slette CutscenePlayer og sende CutsceneEvent med en hvilken som helst værdi. For en cutscene betyder det næsten ingenting, hvis intet rigtigt afhænger af den.

Hvad en snyder kan prøve, og hvad der kommer ud af det
Snyderen prøverResultat
Springe cutscenen over eller slet ikke afspille denKan godt: det er snyderens egen skærm. Giv aldrig en belønning for "så cutscenen til ende".
Sende CutsceneEvent med en hvilken som helst værdiKun et tal, der matcher den nuværende cutscene, gør noget, og alt, hvad det gør, er at frigøre snyderen tidligere.
Røre triggeren fra et hvilket som helst sted på kortetMuligt: hver enhed styrer sin karakter, og Robloxs sikkerhedsdokumentation nævner forfalskning af Touched-events blandt de ting, den kan gøre. Snyderen ser den cutscene én gang, og der sker ikke mere.
Bevæge sig alligevel under cutscenenDer er intet at vinde. Frysningen forhindrer ærlige spillere i at gå væk midt i en cutscene; det er ikke et sikkerhedstjek.
Starte en cutscene for en anden via en remoteUmuligt. Kun serveren kan sende CutsceneEvent til en spiller, og det eneste, en enhed kan sende tilbage, er "denne cutscene er slut".

Hvis en cutscene fører til noget rigtigt, for eksempel en dør, der derefter åbner, eller en boss, der dukker op, så lad serveren gøre det efter sin egen timer og ikke, når enheden melder, at cutscenen er slut.

Trin 5: test det

  1. Placér tre Intro-billeder med Command Bar-linjen. Giv billede 1 Caption "Welcome to the village", billede 2 MoveSeconds 2.5 og Caption "Find the bridge", og lad billede 3 være uden attributter.
  2. Tryk på Play (F5). Sorte bjælker dukker op, kameraet skifter til billede 1 med dets undertekst, flyver på 2.5 sekunder til billede 2 og derefter på 3 sekunder til billede 3 uden undertekst. Derefter vender kameraet tilbage bag karakteren, og spillerlisten dukker op igen. Mens den kører, kan du ikke gå.
  3. Stop testen, tryk på Play igen, og tryk på Skip, mens kameraet flyver mod billede 2. Kameraet vender straks tilbage, og du kan straks gå.
  4. Gå ind i BridgeTrigger: cutscenen Bridge afspilles. Gå gennem den igen: der sker ingenting.
  5. Vælg Server & Clients i rullemenuen med testtilstande, sæt 2 klienter, og tryk på Play. Når Client 1 går ind i triggeren, afspilles cutscenen Bridge kun for Client 1, og Client 2 kan gå.
  6. Lad Workspace.StreamingEnabled være slået til, og flyt ét billede langt væk fra spawn. Når kameraet ankommer, skal omgivelserne være på plads (sandsynligvis, men ikke garanteret: se Streaming).
  7. Til gamepad stopper du testen, trykker på Play, åbner Controller Emulator (fanen Emulation, derefter Controller) og går ind i BridgeTrigger med den emulerede gamepad: Skip skal være valgt, så A springer cutscenen over. Hvis du bruger Device Simulator i Studio (da vi tjekkede 15. oktober 2026, var det en beta: slå den til under File, Beta Features, New Device Simulator, og genstart Studio), så vælg en telefon, drej den vandret, og tjek, at Skip ikke går ind under kameraets udskæring og er nem at ramme, og at sticken og hopknappen er skjult, mens cutscenen kører.
  8. Hvis du også har lavet en hovedmenu, så tryk på Play, derefter på Play-knappen i menuen, og lad introen køre til ende: bagefter skal spillerlisten være på skærmen igen.

Hold Output-vinduet åbent hele tiden (menuen Window, derefter Output). Når alt virker, skriver disse scripts ingenting, så enhver advarsel eller rød fejl fra CutsceneService eller CutscenePlayer er et reelt problem. Se Almindelige fejl.

Sådan udvider du systemet

Intro kun ved spillerens første besøg

Tabellen seen lever én server, så en spiller, der kommer ind igen, ser introen igen. For kun at vise den ved første besøg gemmer du et flag, for eksempel SeenIntro, sammen med spillerens øvrige data via modulet PlayerData fra DataStore-tutorialen. Lad INTRO_CUTSCENE være, og ændr den del af onCharacterAdded i CutsceneService, der står for introen: vent, til PlayerData.Get(player) returnerer spillerens data, spring introen over, hvis data.SeenIntro er true, og sæt kun data.SeenIntro = true, når playOnce(player, INTRO_CUTSCENE) har returneret true. Start ikke introen fra den kode, der indlæser data: data kan blive indlæst, før karakteren spawner, og uden karakter gør play ingenting, og flaget gemmes for en intro, ingen så.

Figurer, der spiller med i cutscenen

Lav en animation i Animation Editor i Studio eller i et tredjeparts animationsplugin, for eksempel Moon Animator, som nævnes i Robloxs dokumentation, og afspil den på en NPC-rig i billedet, når kameraet ankommer. Roblox-referencen for Animator siger, at NPC-animationer kun replikeres, hvis serveren indlæser og starter dem, så afspil den fra et server-Script, hvis alle spillere skal se NPC'en spille. Hvis du indlæser og starter den i CutscenePlayer, replikeres animationen ikke, og det passer til en cutscene, som kun én spiller ser. Guiden til animation-scripts viser, hvordan du afspiller en animation på en NPC fra et server-Script.

Dialoger

Undertekster passer til korte repliker, der kører af sig selv. Til en samtale, hvor spilleren svarer og vælger muligheder, se guiden til NPC-dialoger.

Intro efter hovedmenuen

Guiden til hovedmenuer slår CharacterAutoLoads fra, så ingen spawner, før de trykker på Play. CutsceneService afspiller introen ved spillerens første spawn, så med begge systemer afspilles introen ved første spawn efter Play. Menuen slår core GUI til igen, når karakteren dukker op, og det kan ske, mens introen allerede kører, så spillerlisten kan være synlig under introen. CutscenePlayer slår kun det til igen, som den selv skjulte, så den rører ikke menuens ændring, og efter introen forbliver de slået til. Command Bar-tricket fra guiden til hovedmenuer til at rette en kamera-part ind er det samme som i trin 1.

Flyvetur over kortet ved rundens start

For at starte en cutscene fra et andet server-script, for eksempel en flyvetur over kortet i starten af en runde fra guiden til rundesystemer, tilføjer du en BindableEvent med navnet PlayCutscene i ServerStorage. I slutningen af CutsceneService forbinder du dens Event til funktionen play, og lader rundescriptet kalde den med hver spiller og cutscenens navn. play springer tjekket "én gang pr. server" over, så flyveturen afspilles hver runde.

Plugins til cutscenes

Plugins kan bruges sammen med denne guide. Hvis et cutscene-plugin skriver sit eget kamera-script, så tjek, at det giver kameraet tilbage (CameraType Custom og CameraSubject) og sætter Focus, mens kameraet er Scriptable, og lad beslutningen om, hvem der ser cutscenen, blive på serveren, som i denne guide.

Almindelige fejl og løsninger

Åbn Output-vinduet (menuen Window, derefter Output), før du trykker på Play. De fleste problemer med cutscenes skriver enten en advarsel der eller skyldes et navn, der ikke passer.

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

CutsceneService venter på en mappe med navnet Cutscenes direkte i Workspace. Opret den som i trin 1, og tjek stavningen og det store C. Indtil den findes, opretter CutsceneService ikke CutsceneEvent, så CutscenePlayer venter også.

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

CutscenePlayer venter på den remote, som CutsceneService opretter. Tjek, at CutsceneService er et Script og ikke et LocalScript, ligger direkte i ServerScriptService, ikke er slået fra, og at der ikke er nogen fejl eller advarsel om Cutscenes fra det i Output.

CutsceneService: no folder named Intro in Workspace.Cutscenes

Navnet i INTRO_CUTSCENE eller i triggerens attribut Cutscene passer ikke med nogen mappe inde i Workspace.Cutscenes. Store og små bogstaver i navnene betyder noget.

Intet afspilles, og Output er tomt

Mappen har ingen part med navnet 1, eller dens parts ligger ikke direkte i den (for eksempel inde i en Model). CutsceneService læser parts 1, 2, 3 i rækkefølge og stopper ved det første manglende nummer. Og husk, at hver cutscene afspilles én gang pr. spiller pr. server: stop testen, og tryk på Play igen.

Kameraet kigger den forkerte vej

Kameraet kigger samme vej som billed-partens forside. Flyt Studio-kameraet hen til den ønskede udsigt, og kør Command Bar-linjen fra trin 1 igen for det billede.

Triggeren gør ingenting

Tjek, at trigger-parten ligger direkte inde i Workspace.CutsceneTriggers, når spillet starter, at CanTouch er sat (ellers kommer der en advarsel i Output), og at dens attribut Cutscene er en streng med navnet på en mappe i Workspace.Cutscenes. At gå gennem triggeren igen gør ingenting, og det er meningen.

Efter cutscenen bliver kameraet på det sidste billede

CutscenePlayer stoppede med en fejl, før den nåede at give kameraet tilbage, så led efter en rød fejl fra den i Output. Kameraet kan også holdes af et andet script, der hele tiden sætter CameraType til Scriptable, for eksempel et menukamera, der stadig er bundet.

Lav det med RoCode

Hvis du ikke har lyst til at bygge det her i hånden, kan RoCode gøre det i det place, du har åbent. RoCode er en uafhængig AI-agent til Roblox Studio, ikke fra Roblox: du beskriver funktionen i dens webchat, og dens Studio-plugin opretter parten og scripts i din Explorer, så du ikke behøver at kopiere kode fra et chatvindue.

Du skriver

Tilføj en intro-cutscene: en mappe Cutscenes med mappen Intro og billederne 1 til 3, undertekster fra attributten Caption, sorte bjælker og en Skip-knap, afspilles én gang ved spillerens første spawn, serveren holder spilleren på stedet, og til sidst vender kameraet tilbage.

RoCode gør
  • Kan først tjekke dit place med Search Scripts, for eksempel for et menu- eller kamera-script, der allerede sætter CameraType, så de ikke konflikter
  • Opretter mapperne og trigger-parten med Create Instance og sætter attributter som Caption og MoveSeconds på parterne
  • Skriver CutsceneService og CutscenePlayer med Create Script
  • Den er instrueret i at tjekke hvert script, den skriver, med Check Script, som kompilerer det i Studio uden at køre det, og den sætter et fortrydelsespunkt før og efter hver pakke ændringer

Placér selv billed-parterne ved at flytte Studio-kameraet hen til hver udsigt, og bed derefter om scripts. Med plugin 3.9 eller nyere kan RoCode køre en kort playtest og læse fejlene, og med plugin 3.9.11 eller nyere kan den styre en testfigur for at tjekke, at spillet virker, men under spillet tager den ingen skærmbilleder, så cutscenen ser du selv. Rækkefølgen for at bygge et helt spil findes på siden sådan laver du et spil i Roblox med AI, system for system. Sådan forbinder RoCode til Studio.

Ofte stillede spørgsmål

Hvordan får jeg en cutscene til at afspille, når man kommer ind i spillet?

Kald mappen med billeder Intro i Workspace.Cutscenes, eller ændr INTRO_CUTSCENE til navnet på din mappe. CutsceneService afspiller den ved hver spillers første spawn på serveren. For kun at vise den ved det allerførste besøg gemmer du et flag i et data store og sætter det først, når introen er startet, som beskrevet i afsnittet Sådan udvider du systemet.

Kan man lave en cutscene uden plugins?

Ja. Denne guide bruger kun parts, attributter og to scripts, og Command Bar-linjen sætter hvert billede præcis der, hvor Studio-kameraet står. Plugins som Moon Animator er stadig praktiske til at animere figurer, der spiller med i cutscenen.

Hvorfor bevæger kameraet sig ikke i cutscenen?

Som regel ligger kamerakoden i et server-Script, men kun et LocalScript kan flytte spillerens kamera, fordi hver enhed har sit eget kamera. En anden almindelig årsag: CameraType er ikke Scriptable, og Robloxs standard-kamera-scripts sætter hele tiden kameraet tilbage til karakteren.

Hvordan forhindrer jeg spilleren i at bevæge sig under en cutscene?

Ankr spillerens HumanoidRootPart på serveren, mens den kører, og fjern ankringen bagefter, som CutsceneService gør. En ankret part bevæger sig aldrig på grund af fysik. WalkSpeed røres ikke, så det konflikter ikke med et sprint-script eller et speed-pass.

Hvordan tilføjer jeg en Skip-knap til en cutscene?

Læg en TextButton på cutscene-skærmen, og forbind dens event Activated, der udløses ved klik, tryk eller knappen A på en gamepad, når knappen er valgt. Skip i CutscenePlayer sætter et flag, som billedløkken tjekker hvert frame, vælger sig selv for spillere med gamepad og ligger i sin egen ScreenGui med standardmargener, så telefonens kameraudskæring ikke dækker den. Sticken og hopknappen er skjult, mens cutscenen kører, så de står ikke ved siden af den.

Hvorfor er verden tom i cutscenen?

Med instance streaming slået til har spillerens enhed kun området nær sin karakter. Lad serveren kalde player:RequestStreamAroundAsync for hvert billede kort før kameraet flyver derhen, som CutsceneService gør. Roblox skriver, at området så sandsynligvis, men ikke sikkert, bliver indlæst, så hold vigtige billeder inden for streaming-radius, eller brug Player:AddReplicationFocus til et område, der skal forblive indlæst.

Kilder og videre læsning

Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.

Prøv RoCode i dit eget spil.

Gratis credits hver dag, intet kort. Installér pluginet, beskriv en funktion, og se hvad der dukker op i Studio.