Tutorial · Spillsystemer

Slik lager du en cutscene i Roblox Studio

En cutscene i Roblox er et kamera som tar over kontrollen i noen sekunder: det bytter eller glir mykt mellom bilder, viser en tekst og gir kontrollen tilbake til spilleren. I denne guiden bygger vi en cutscene som du setter opp ved å plassere usynlige parts der kameraet skal stå, uten plugins. Serveren bestemmer når spilleren ser den (ved første spawn eller når en trigger berøres), og spillerens enhet flytter kameraet, viser svarte striper og en Skip-knapp og gir kameraet tilbake.

Oppdatert 20. november 202622 min lesingSkrevet av

Kort fortalt

Plasser usynlige, anchored parts med navnene 1, 2, 3 i en mappe inne i Workspace.Cutscenes, hver med forsiden dit kameraet skal se. Et Script i ServerScriptService leser CFrame-ene deres, holder spilleren på plass og sender bildene til den spilleren via en RemoteEvent. Et LocalScript i StarterPlayerScripts setter workspace.CurrentCamera.CameraType til Scriptable, flytter kameraet fra bilde til bilde hver frame (myknet med TweenService:GetValue) og setter så CameraType tilbake til Custom og CameraSubject til spillerens Humanoid.

  • Bare spillerens enhet kan styre kameraet, så kamerakoden er et LocalScript. Serveren bestemmer bare hvem som ser hvilken cutscene og når.
  • Når kameraet er Scriptable, slutter Roblox å oppdatere Camera.Focus. Dokumentasjonen sier at du skal oppdatere Focus hver frame, ellers kan dynamisk lys langt fra det gamle fokuset la være å tegnes.
  • Camera:Interpolate er utdatert. Dokumentasjonen til Roblox sier at du skal animere kameraet med TweenService.
På denne siden
  1. Slik virker det
  2. 1. Bilder
  3. 2. Serverskript
  4. 3. LocalScript
  5. 4. Trigger
  6. Kameradetaljer
  7. Eldre tutorials
  8. Beskyttelse mot juks
  9. 5. Test
  10. Utvidelser
  11. Common errors
  12. Med RoCode
  13. Ofte stilte spørsmål
  14. Kilder og videre lesing

Slik virker en cutscene

IllustrasjonEn intro med to bilder i ekte hastighet: bytte til første bilde, pause på 1 sekund, overgang til broen på 2.5 sekunder, pause på 1 sekund, så går kameraet tilbake til spilleren.

Hver spillers enhet har sitt eget Camera-objekt, i workspace.CurrentCamera, så bare et LocalScript kan flytte det spilleren ser. Å bestemme hvem som ser hvilken cutscene og når, er serverens jobb. Guiden deler arbeidet akkurat slik. Én cutscene går slik:

  1. Serveren bestemmer at spilleren skal se en cutscene: Intro ved første spawn på serveren, eller en annen når han berører en trigger-part.
  2. CutsceneService leser CFrame og innstillinger fra bilde-partene, ber Roblox laste inn området rundt det første bildet for denne spilleren, gjør spillerens HumanoidRootPart anchored så han står stille, og sender CutsceneEvent bare til den spilleren med en id og listen over bilder.
  3. CutscenePlayer på spillerens enhet viser svarte striper og en Skip-knapp, skjuler spillerlisten, ryggsekken, helselinjen og berøringskontrollene, gjør kameraet Scriptable og flytter det hver frame.
  4. Når det siste bildet er ferdig eller spilleren trykker på Skip, gir den kameraet tilbake til karakteren og sender CutsceneEvent til serveren med samme id.
  5. Serveren fjerner anchor fra spilleren. Hvis den meldingen aldri kommer, fjerner den anchor likevel når lengden på cutscenen pluss 2 sekunder har gått. Tidtakeren starter når serveren sender cutscenen, og ved treg innlasting kan enheten starte introen noen sekunder senere, fordi et LocalScript utenfor ReplicatedFirst ikke starter før spillet er lastet inn. Da kan spilleren bevege seg igjen før introen er ferdig på skjermen hans.
Hva cutscene-systemet består av
DelHvor den liggerHva den gjør
Script CutsceneServiceServerScriptServiceBestemmer hvem som ser hvilken cutscene og når, leser bildene, holder spilleren på plass og husker hvem som allerede har sett hva.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsSpiller av cutscenen på spillerens skjerm: striper, tekst, Skip og kamerabevegelse. Til slutt gir den kameraet tilbake.
RemoteEvent CutsceneEventReplicatedStorage (CutsceneService lager den)Bærer bildene fra serveren til én spiller, og meldingen "cutscenen er ferdig" tilbake.
Folder CutscenesWorkspaceÉn mappe per cutscene, for eksempel Intro, med bilde-partene 1, 2, 3.
Folder CutsceneTriggersWorkspace (valgfritt)Parts som starter en cutscene når en spiller berører dem.
Explorer når cutscene-systemet er ferdig. Mappene Bridge og CutsceneTriggers kommer i steg 4. Når spillet starter, legger CutsceneService til 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

Steg 1: Plasser kamerabildene

Hvert bilde er en usynlig part. Kameraet tar partens posisjon og ser samme vei som forsiden dens, så å plassere et bilde er det samme som å plassere kameraet.

  1. Hold musen over Workspace i Explorer, klikk på knappen + og sett inn en Folder med navnet Cutscenes. Sett inn en Folder med navnet Intro inne i den. Store og små bokstaver i navnene betyr noe.
  2. Flytt Studio-kameraet til den første utsikten du vil ha, som om du komponerer et bilde for et foto.
  3. Sett inn en Part i Intro og gi den nytt navn, 1.
  4. Åpne Command Bar (på fanen Script eller via Window og så Script) og kjør workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. I redigeringsmodus er CurrentCamera utsikten du ser gjennom, så parten havner nøyaktig i dette bildet. Klammene og anførselstegnene trengs fordi et navn som begynner med et tall, ikke kan skrives etter et punktum.
  5. Huk av Anchored i partens Properties, fjern haken for CanCollide, CanTouch og CanQuery, og sett Transparency til 1. Anchored hindrer at den faller gjennom kartet; resten hindrer at den er i veien for spillere, utløser berøringshendelser og blokkerer raycasts.
  6. Gjenta for de neste utsiktene, gi partene navnene 2, 3 og så videre, og bytt nummeret i linjen for Command Bar. CutsceneService spiller bildene i nummerrekkefølge og stopper ved det første nummeret som mangler, så et hull i nummereringen avslutter cutscenen for tidlig.

For å endre et bilde senere flytter du kameraet til den nye utsikten og kjører den samme linjen med nummeret til bildet. Med Transparency 1 er partene usynlige også i Studio, så velg dem i Explorer når du trenger dem.

Hvert bilde kan ha tre valgfrie attributter i tillegg. For å legge til en attributt velger du parten, ruller vinduet Properties ned til delen Attributes, klikker på +, skriver inn navnet, velger typen og klikker på Save.

Valgfrie attributter på hver bilde-part
AttributtTypeStandardHva den gjør
MoveSecondsnumber3Hvor mange sekunder kameraet bruker fra forrige bilde til dette. 0 gir et brått bytte. Bilde 1 er alltid et bytte, så attributten virker ikke på det.
HoldSecondsnumber1Hvor mange sekunder kameraet står stille på dette bildet etter at det har kommet fram.
CaptionstringingenTekst på den nederste stripen fra det øyeblikket kameraet begynner å bevege seg mot dette bildet. Et bilde uten Caption tømmer teksten.

Et tall under 0 eller over 60, og en attributt av feil type, byttes ut med standardverdien.

Steg 2: Legg til serverskriptet

Hold musen over ServerScriptService, sett inn et Script med navnet CutsceneService og lim inn koden nedenfor. Innstillingene øverst er linjene du kan endre.

Script i ServerScriptService med navnet CutsceneService
-- Script i ServerScriptService med navnet CutsceneService.
-- Bestemmer hvem som ser hvilken cutscene og når. Leser kamerabildene fra nummererte
-- parts i Workspace.Cutscenes, holder spilleren på plass og ber enheten
-- til denne spilleren spille av bildene. Selve kameraet kan bare flyttes på enheten.

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

-- Innstillinger
local INTRO_CUTSCENE = "Intro" -- spilles én gang ved spillerens første spawn; "" for å slå av
local DEFAULT_MOVE_SECONDS = 3 -- tiden for overgangen til et bilde hvis det ikke har MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- tiden på et bilde hvis det ikke har HoldSeconds
local MAX_SHOTS = 30

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

-- Dette skriptet lager CutsceneEvent selv, så ikke legg den til for hånd
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-en til cutscenen spilleren ser på
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

-- Bildene er partene 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 bildet er et bytte, så kameraet hopper rett dit
			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 cutscenen er allerede ferdig
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- én cutscene om 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 slått på har spillerens enhet kanskje ikke området
	-- som bildet ser på, og forespørselen laster bare inn området midlertidig. Vi laster
	-- området rundt det første bildet nå (venter opptil 2 sekunder), og området rundt hvert neste
	-- 2 sekunder før kameraet beveger seg dit.
	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 gikk mens området ble lastet inn
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- sekunder fra nå til overgangen til dette bildet 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
	-- Sikkerhetsnett: vi frigjør spilleren selv om enheten hans aldri svarte
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Returnerer true bare hvis cutscenen startet for denne spilleren
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 enhet melder at cutscenen er ferdig eller hoppet over
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Trigger-parts: en berøring starter cutscenen fra attributten Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Å koble Touched til en part med CanTouch slått av gir en feil, så vi bare advarer
			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, vi holder den nye karakteren på plass også
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- allerede satt opp
	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 som kom inn mens skriptet ventet på Cutscenes
	onPlayerAdded(player)
end

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

CutsceneService lager selv RemoteEvent-en CutsceneEvent så snart Workspace.Cutscenes finnes, så du trenger ikke sette inn noe i ReplicatedStorage for hånd. Hvis du allerede har laget en RemoteEvent med det navnet, slett den: LocalScript-et kan finne din, og ingen lytter på den på serveren.

Innstillingene øverst i CutsceneService
InnstillingVerdi herHva den endrer
INTRO_CUTSCENE"Intro"Mappen i Workspace.Cutscenes som spilles ved spillerens første spawn på serveren. Sett "" for å ikke ha noen intro.
DEFAULT_MOVE_SECONDS3Hvor lenge en overgang varer hvis bildet ikke har attributten MoveSeconds.
DEFAULT_HOLD_SECONDS1Hvor lenge kameraet står på et bilde hvis det ikke har attributten HoldSeconds.
MAX_SHOTS30Det høyeste bildenummeret CutsceneService ser etter i én cutscene.

Hva resten av skriptet gjør, i rekkefølge:

  • Leser bildene på serveren. readShots samler CFrame og attributter fra hver nummerert part i en liste. Spillerens enhet får denne listen, så den trenger ikke selve partene.
  • Én cutscene om gangen. play gjør ingenting mens spilleren allerede ser en cutscene, eller hvis karakteren hans ikke har en Humanoid eller er død.
  • Hver cutscene har sin egen id. Enheten sender id-en tilbake når cutscenen er ferdig eller hoppet over, og bare en id som stemmer, frigjør spilleren, så en forsinket melding fra en tidligere cutscene ikke kan avslutte en ny.
  • Holder spilleren på plass ved å gjøre HumanoidRootPart anchored, og gjør den nye karakteren anchored hvis spilleren respawner midt i en cutscene. Dokumentasjonen til Roblox sier at en anchored part aldri endrer posisjon på grunn av tyngdekraft, kollisjoner eller annen fysikk. WalkSpeed røres ikke, så dette kolliderer ikke med et sprintskript eller en pass for fart. Til slutt fjerner skriptet anchor fra root part selv om et annet skript gjorde den anchored, så ikke gjør karakterer anchored andre steder mens en cutscene kan pågå.
  • Sikkerhetsnett. task.delay frigjør spilleren etter hele lengden på cutscenen pluss 2 sekunder, selv om enheten hans aldri svarte.
  • Hver cutscene én gang per server. Tabellen seen husker for hver spiller hvilke cutscener som allerede har startet, så introen gjentas ikke ved respawn, og en cutscene fra en trigger spilles én gang. playOnce returnerer true bare hvis cutscenen faktisk startet.
  • Setter opp hver spiller. Løkken over Players:GetPlayers() til slutt fanger opp alle som kom inn mens skriptet ventet på mappen Cutscenes.

Bildene sendes til spilleren i ett FireClient-kall, som en liste med små tabeller. Siden til Roblox om remote events sier at du ikke skal sende en tabell med blandede tall- og tekstnøkler; denne listen har bare tallnøkler, og hvert bilde inni har bare tekstnøkler, som er formen som anbefales der.

Steg 3: Legg til LocalScript-et som spiller den av

  1. Utvid StarterPlayer i Explorer, hold musen over StarterPlayerScripts og sett inn et LocalScript med navnet CutscenePlayer.
  2. Bytt ut innholdet med koden nedenfor.
LocalScript i StarterPlayerScripts med navnet CutscenePlayer
-- LocalScript i StarterPlayer > StarterPlayerScripts med navnet CutscenePlayer.
-- Spiller av cutscenen serveren sender: svarte striper, tekst, en Skip-knapp og
-- et kamera som beveger seg fra bilde til bilde. Gir så kameraet tilbake 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 svarte stripe, som andel av skjermhøyden
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- hvor mange studs foran kameraet Roblox skal tegne mest detaljert
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-skjermen: to svarte striper og en tekst, fra kant til kant. Roblox anbefaler
-- ScreenInsets None bare for det 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 skjermen
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 standardmarger, så kamerahullet ikke dekker 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 stripen, til høyre
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 forblir stor nok til å treffe på en liten 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

-- Gjeldende overgang: fra én kamera-CFrame til den neste på et gitt antall sekunder
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Kjører hver frame under cutscenen. Focus på et Scriptable-kamera følger
-- ingenting av seg selv, så det settes her også.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- noe tilbakestilte den, 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 spilles allerede, så la serveren frigjøre spilleren for denne med en gang
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Skjuler spillerlisten, ryggsekken og helselinjen, og husker hva som var synlig
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- På telefoner skjuler vi styrespaken og hoppeknappen, som står i de nederste hjørnene
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- En gamepad kan bare trykke på den valgte knappen, så for gamepad-spillere velger vi Skip
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Ett steg etter Roblox sin egen kameraoppdatering, som i kameratutorialen til Roblox
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

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

	-- Gir kameraet tilbake 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år bare på igjen det denne cutscenen slo av, resten rører vi ikke
	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 frigjør spilleren med en gang
	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, når han kommer inn, og fortsetter å kjøre etter at karakteren respawner. Derfor har begge ScreenGui-ene ResetOnSpawn slått av: hvis du slår det på, sletter Roblox dem ved første respawn, og dette skriptet lager dem ikke på nytt. Meldinger fra remote-en som kommer før skriptet har koblet seg til OnClientEvent, settes i kø og leveres etter tilkoblingen, så en spiller som spawnet raskt, ser likevel introen.

Hva hver del av CutscenePlayer gjør
DelHva den gjør
ScreenGui CutsceneTo svarte striper, hver på 12 % av skjermhøyden (BAR_HEIGHT), og teksten på den nederste stripen. ScreenInsets None strekker stripene helt ut til kantene av skjermen, og DisplayOrder 10 tegner dem over ScreenGui-er med lavere DisplayOrder.
ScreenGui CutsceneControlsInneholder bare Skip-knappen, til høyre på den nederste stripen, med en UISizeConstraint som holder den på minst 64 ganger 32 piksler, så den er lett å treffe på en telefon. Den har standard ScreenInsets, og innholdet går ikke inn under knappene i den øverste linjen til Roblox og kamerahull. Roblox anbefaler None bare for innhold det ikke er noe å trykke på, så Skip kan ikke bo i ScreenGui-en med stripene.
HIDDEN_CORE_GUISSkjuler spillerlisten, ryggsekken og helselinjen med SetCoreGuiEnabled, etter først å ha husket med GetCoreGuiEnabled hvilke som var på, og slår til slutt bare på igjen dem den slo av selv. Hvis spillet skjuler ryggsekken et annet sted, forblir den skjult, og et skript som slår dem på under cutscenen, for eksempel en hovedmeny, blir ikke overkjørt.
TouchControlsEnabledPå telefoner og nettbrett setter play GuiService.TouchControlsEnabled til false mens cutscenen varer. Det skjuler styrespaken og hoppeknappen, som står i de nederste hjørnene, samme sted som Skip, og til slutt kommer de tilbake hvis de var på.
updateCameraKjører hver frame mens cutscenen pågår. Regner ut hvor stor del av den gjeldende overgangen som er gått, mykner den med TweenService:GetValue, plasserer kameraet mellom to bilder med CFrame:Lerp og setter Focus 30 studs foran kameraet.
waitOrSkipVenter tiden for overgangen og pausen på bildet, og sjekker Skip-flagget hver frame.
playGjør kameraet Scriptable, spiller bildene i rekkefølge, gir så kameraet tilbake (CameraType Custom, CameraSubject er Humanoid), slår på igjen core GUI og berøringskontrollene og sender cutscenens id til serveren. Hvis en ny cutscene kommer mens den første fortsatt spilles, sender den id-en tilbake med en gang, så serveren ikke holder spilleren fast for en cutscene denne enheten ikke viste.
Skip-knappenActivated utløses av et museklikk, et trykk eller A-knappen på en gamepad når knappen er valgt. For en spiller som bruker gamepad som hovedinndata, velger play Skip i starten av cutscenen og fjerner valget til slutt.

Endre BAR_HEIGHT for å gjøre stripene tynnere eller tykkere, og EASING_STYLE for å endre følelsen i overgangene (se Hva kamerakoden gjør riktig). Teksten og Skip-knappen har TextScaled slått på, så teksten vokser og krymper med skjermen.

Steg 4: En cutscene når en part berøres

Introen spilles av seg selv. For en cutscene på et bestemt sted på kartet, for eksempel når spilleren kommer til broen for første gang, legger du til en ny cutscene og en trigger-part.

  1. Sett inn en Folder med navnet Bridge i Workspace, Cutscenes og plasser bildene som i steg 1, med navnene 1 og 2. I linjen for Command Bar skriver du Bridge i stedet for Intro.
  2. Hold musen over Workspace og sett inn en Folder med navnet CutsceneTriggers.
  3. Sett inn en Part med navnet BridgeTrigger i den. Gjør den så stor at spillere ikke kan gå forbi uten å berøre den, for eksempel en høy, bred plate på tvers av veien. Huk av Anchored, fjern haken for CanCollide og CanQuery, la CanTouch være avhuket, og sett Transparency til 1. Når CanQuery er av, blokkerer ikke den usynlige platen raycasts, for eksempel skudd fra guiden til våpen. Berøringshendelser styres av CanTouch og ikke CanQuery, så triggeren virker likevel.
  4. Gi den en attributt Cutscene av typen string og sett verdien til Bridge: navnet på mappen som skal spilles.

CutsceneService kobler Touched til hver part rett inne i CutsceneTriggers når serveren starter, så legg til triggere i Studio og ikke med et skript mens spillet kjører. En trigger med CanTouch slått av hoppes over med en advarsel i Output, fordi Roblox gir en feil når et skript kobler Touched til en slik part.

Mens karakteren går gjennom parten, utløses Touched mange ganger på rad. Tabellen seen og regelen "én cutscene om gangen" gjør det om til én cutscene per spiller per server. En spiller som berører triggeren under en annen cutscene, ignoreres, og triggeren forblir klar for ham.

Ikke sett triggere på veier. HumanoidRootPart til en spiller som sitter, er sveiset til setet, og når én part i en sveiset gruppe er anchored, gjør Roblox resten anchored sammen med den. Derfor holder en spiller som kjører inn i en trigger, hele kjøretøyet sitt fast, passasjerene også, til cutscenen er ferdig.

Hva kamerakoden gjør riktig

Scriptable, så tilbake til Custom

Kameraskriptene til Roblox flytter og oppdaterer ikke kameraet mens CameraType er Scriptable, og det er nettopp det som lar CutscenePlayer plassere det. Til slutt setter den CameraType tilbake til Custom og gjør spillerens Humanoid til CameraSubject, som kameraskriptene til Roblox følger som standard. Dette kjøres også etter Skip, så spilleren blir aldri stående og se på det siste bildet.

To små sjekker holder cutscenen i kontroll mens den spilles. Hvis noe setter CameraType til en annen verdi midt i cutscenen, setter funksjonen som kjører hver frame den tilbake til Scriptable i neste frame. Og workspace.CurrentCamera leser skriptet på nytt i starten av hver cutscene, fordi Roblox lager et nytt Camera hvis det gjeldende noen gang slettes.

Focus, hver frame

Camera.Focus forteller motoren hvilket område som skal prioriteres i arbeid som lys. Kameraskriptene til Roblox holder det på CameraSubject, men ikke når kameraet er Scriptable, og dokumentasjonen til Roblox sier at du da skal oppdatere det hver frame: dynamisk lys fra objekter som PointLight kan la være å tegnes langt fra fokuset. CutscenePlayer setter det 30 studs foran kameraet (FOCUS_DISTANCE). Øk tallet hvis bildene dine ser på noe som er lenger unna.

Funksjonen kjører via RunService:BindToRenderStep, hver frame før tegning, ett prioritetssteg etter Roblox sin egen kameraoppdatering (Enum.RenderPriority.Camera.Value + 1). Denne prioriteten brukes i kameratutorialen til Roblox, så cutscenen plasserer kameraet etter at Roblox sin egen kamerakode har kjørt.

Myke overganger med TweenService:GetValue

En tween på camera.CFrame ville flyttet kameraet, men Focus må likevel settes hver frame, så CutscenePlayer flytter kameraet selv i samme funksjon. For hver overgang regner den ut hvor stor andel av tiden som har gått (fra 0 til 1), sender den gjennom TweenService:GetValue med en easing-stil og -retning og plasserer kameraet på den andelen av veien mellom to bilder med CFrame:Lerp, som flytter posisjonen i en rett linje og roterer mykt. GetValue begrenser inndata til mellom 0 og 1, så kameraet stopper nøyaktig på bildet når tiden for overgangen er ute.

Easing-stiler som passer for en kameraovergang
EASING_STYLEHvordan overgangen føles
Enum.EasingStyle.Sine (her)Farten følger en sinuskurve, myk start og myk stopp.
Enum.EasingStyle.QuadSom Sine, men kurven er litt skarpere.
Enum.EasingStyle.LinearKonstant fart, så hver overgang starter og slutter i full fart.

Retningen InOut: easing brukes forover i første halvdel av overgangen og baklengs i andre halvdel, så kameraet akselererer fra ett bilde og bremser mot det neste.

Streaming

I nye places er instance streaming slått på: som standard holder spillerens enhet området rundt karakteren hans, så et bilde som ser mot den andre enden av kartet, kan vise en tom verden. CutsceneService ber Roblox laste inn området rundt hvert bilde for denne spilleren med Player:RequestStreamAroundAsync: området rundt det første bildet før hendelsen sendes, med opptil 2 sekunders venting, og området rundt hvert neste 2 sekunder før kameraet beveger seg dit.

Roblox skriver at området da sannsynligvis, men ikke sikkert, blir lastet inn, og at effekten er midlertidig. Hold viktige bilder innenfor streaming-radiusen, eller bruk Player:AddReplicationFocus på serveren for et område som skal forbli lastet inn til du fjerner fokuset. Med streaming slått av har enheten hele kartet uansett, og pcall rundt hver forespørsel betyr at en mislykket forespørsel ikke kan stoppe cutscenen.

Hva som er galt i eldre cutscene-tutorials

Hvis du sammenligner denne guiden med en video eller et foruminnlegg, er dette forskjellene som betyr noe, og hvorfor hvert triks er et problem.

Vanlige triks i cutscene-tutorials og hva denne guiden gjør i stedet
TutorialProblemDenne guiden
Flytter kameraet med camera:Interpolate()Roblox har merket Interpolate som utdatert og anbefaler å animere kameraet med TweenService.Mykner hver overgang med TweenService:GetValue og plasserer kameraet hver frame.
Tweener camera.CFrame og ingenting annetFocus blir værende der kameraskriptene forlot det, ved karakteren, så dynamisk lys langt fra det kan la være å tegnes (dokumentasjonen til Roblox for Camera.Focus).Setter Focus hver frame i render step.
Gir ikke kameraet tilbakeSpilleren blir sittende fast og se på det siste bildet.Setter til slutt CameraType til Custom og CameraSubject til Humanoid, også etter Skip.
Starter cutscenen fra Touched i et LocalScriptIngenting hindrer at den gjentas ved hver berøring, og avgjørelsen tas på enheten spilleren styrer.Serveren velger spilleren og husker hvem som allerede har sett den.
Leser kamera-partene på klientenMed streaming slått på finnes kanskje ikke parts langt fra karakteren på enheten ennå.Serveren leser partene, sender CFrame-ene og ber om området rundt hvert bilde like før kameraet kommer dit.

Hva spilleren kan og ikke kan endre

Gå ut fra at en juksemaker styrer alt på sin egen enhet: han kan endre eller slette CutscenePlayer og sende CutsceneEvent med hvilken som helst verdi. For en cutscene betyr det nesten ingenting, så lenge ingenting ekte avhenger av den.

Hva en juksemaker kan prøve, og hva som skjer
Juksemakeren prøver åResultat
Hoppe over cutscenen eller ikke spille den i det hele tattGår an: det er hans egen skjerm. Gi aldri en belønning for "så hele cutscenen".
Sende CutsceneEvent med hvilken som helst verdiBare et tall som stemmer med hans nåværende cutscene, gjør noe, og alt det gjør, er å frigjøre ham tidligere.
Berøre triggeren fra hvor som helst på kartetMulig: hver enhet styrer sin egen karakter, og sikkerhetsdokumentasjonen til Roblox nevner forfalskede Touched-hendelser blant det den kan gjøre. Han ser den cutscenen én gang, og ingenting mer skjer.
Bevege seg likevel under cutscenenDet er ingenting å vinne. Frysingen hindrer ærlige spillere i å gå midt i cutscenen; det er ikke en sikkerhetssjekk.
Starte en cutscene for noen andre via remote-enUmulig. Bare serveren kan sende CutsceneEvent til en spiller, og det eneste enheten kan sende tilbake, er "denne cutscenen er ferdig".

Hvis cutscenen fører til noe ekte, for eksempel en dør som åpnes etterpå eller at en boss dukker opp, la serveren gjøre det på sin egen tidtaker, og ikke når enheten melder at cutscenen er ferdig.

Steg 5: Test det

  1. Plasser tre Intro-bilder med linjen for Command Bar. Gi bilde 1 Caption "Welcome to the village", bilde 2 MoveSeconds 2.5 og Caption "Find the bridge", og la bilde 3 være uten attributter.
  2. Trykk på Play (F5). De svarte stripene dukker opp, kameraet bytter til bilde 1 med teksten, beveger seg til bilde 2 på 2.5 sekunder og så til bilde 3 på 3 sekunder uten tekst. Så går kameraet tilbake bak karakteren, og spillerlisten dukker opp igjen. Mens den spilles, kan du ikke gå.
  3. Stopp testen, trykk på Play igjen og trykk på Skip mens kameraet beveger seg mot bilde 2. Kameraet kommer tilbake med en gang, og du kan gå med en gang.
  4. Gå inn i BridgeTrigger: cutscenen Bridge spilles. Gå gjennom den en gang til: ingenting skjer.
  5. Velg Server & Clients i nedtrekkslisten for testmodus, sett 2 klienter og trykk på Play. Når Client 1 går inn i triggeren, spilles cutscenen Bridge bare hos Client 1, og Client 2 kan gå.
  6. La Workspace.StreamingEnabled være slått på og flytt ett bilde langt fra spawnen. Når kameraet kommer fram, skal omgivelsene være på plass (sannsynligvis, men ikke garantert: se Streaming).
  7. For gamepad: stopp testen, trykk på Play, åpne Controller Emulator (fanen Emulation, så Controller) og gå inn i BridgeTrigger med den emulerte gamepaden: Skip skal være valgt, så A hopper over cutscenen. Hvis du bruker Device Simulator i Studio (da vi sjekket 15. oktober 2026 var den i beta: slå den på i File, Beta Features, New Device Simulator og start Studio på nytt), velg en telefon, snu den på tvers og sjekk at Skip ikke havner under kamerahullet og er lett å treffe, og at styrespaken og hoppeknappen er skjult mens cutscenen pågår.
  8. Hvis du også har laget en hovedmeny, trykk på Play, så på Play-knappen i menyen, og la introen spille ferdig: etterpå skal spillerlisten være på skjermen igjen.

Hold vinduet Output åpent (menyen Window, så Output) hele tiden. Når alt virker, skriver disse skriptene ingenting, så enhver advarsel eller rød feil fra CutsceneService eller CutscenePlayer er et ekte problem. Se Vanlige feil.

Slik utvider du systemet

Intro bare første gang spilleren kommer inn

Tabellen seen lever på én server, så en spiller som kommer inn igjen, ser introen på nytt. For å vise den bare første gang lagrer du et flagg, for eksempel SeenIntro, sammen med resten av spillerens data med modulen PlayerData fra tutorialen om DataStore. La INTRO_CUTSCENE være som den er, og endre delen av onCharacterAdded i CutsceneService som tar seg av introen: vent til PlayerData.Get(player) returnerer spillerens data, hopp over introen hvis data.SeenIntro er true, og sett data.SeenIntro = true bare når playOnce(player, INTRO_CUTSCENE) returnerte true. Ikke start introen fra koden som laster inn data: data kan lastes inn før karakteren spawner, og uten karakter gjør play ingenting, og flagget blir lagret for en intro ingen så.

Karakterer som spiller i cutscenen

Lag en animasjon i Animation Editor i Studio eller i en tredjeparts animasjonsplugin, for eksempel Moon Animator, som nevnes i dokumentasjonen til Roblox, og spill den av på en NPC-rig i bildet når kameraet kommer dit. Dokumentasjonen til Roblox for Animator sier at NPC-animasjoner bare replikeres hvis serveren laster inn og starter dem, så spill den av fra et server-Script hvis alle spillere skal se NPC-en spille. Hvis du laster inn og starter den i CutscenePlayer, replikeres ikke animasjonen, og det passer for en cutscene som bare én spiller ser på. Guiden til animasjonsskript viser hvordan du spiller av en animasjon på en NPC fra et server-Script.

Dialoger

Tekster passer til korte replikker som går av seg selv. For en samtale der spilleren svarer og velger alternativer, se guiden til NPC-dialog.

Intro etter hovedmenyen

Guiden til hovedmeny slår av CharacterAutoLoads, så ingen spawner før de trykker på Play. CutsceneService spiller introen ved spillerens første spawn, så med begge systemene spilles introen ved første spawn etter Play. Menyen slår på core GUI igjen når karakteren dukker opp, og det kan skje når introen allerede spilles, så spillerlisten kan være synlig under introen. CutscenePlayer slår bare på igjen det den skjulte selv, så den rører ikke menyens endring, og etter introen forblir de på. Trikset med Command Bar fra guiden til hovedmeny for å rette inn kamera-parten er det samme som i steg 1.

Flytur over kartet i starten av en runde

For å starte en cutscene fra et annet serverskript, for eksempel en flytur over kartet i starten av en runde fra guiden til rundesystem, legger du til en BindableEvent med navnet PlayCutscene i ServerStorage. Til slutt i CutsceneService kobler du dens Event til funksjonen play, og lar rundeskriptet kalle den med hver spiller og navnet på cutscenen. play hopper over sjekken "én gang per server", så flyturen spilles hver runde.

Plugins for cutscener

Du kan bruke plugins sammen med denne guiden. Hvis en cutscene-plugin skriver sitt eget kameraskript, sjekk at den gir kameraet tilbake (CameraType Custom og CameraSubject) og setter Focus mens kameraet er Scriptable, og la avgjørelsen om hvem som ser cutscenen, ligge på serveren, som i denne guiden.

Vanlige feil og løsninger

Åpne vinduet Output (menyen Window, så Output) før du trykker på Play. De fleste problemer med cutscener skriver enten en advarsel der eller skyldes et navn som ikke stemmer.

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

CutsceneService venter på en mappe med navnet Cutscenes rett i Workspace. Lag den som i steg 1 og sjekk stavemåten og den store C-en. Så lenge den ikke finnes, lager ikke CutsceneService CutsceneEvent, så CutscenePlayer venter også.

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

CutscenePlayer venter på remote-en som CutsceneService lager. Sjekk at CutsceneService er et Script og ikke et LocalScript, ligger rett i ServerScriptService, ikke er slått av, og at det ikke er noen feil eller advarsel om Cutscenes fra det i Output.

CutsceneService: no folder named Intro in Workspace.Cutscenes

Navnet i INTRO_CUTSCENE eller i triggerens attributt Cutscene stemmer ikke med noen mappe inne i Workspace.Cutscenes. Store og små bokstaver i navnene betyr noe.

Ingenting spilles, og Output er tom

Mappen har ingen part med navnet 1, eller partene ligger ikke rett i den (for eksempel inne i en Model). CutsceneService leser partene 1, 2, 3 i rekkefølge og stopper ved det første nummeret som mangler. Og husk at hver cutscene spilles én gang per spiller per server: stopp testen og trykk på Play igjen.

Kameraet ser feil vei

Kameraet ser samme vei som forsiden på bilde-parten. Flytt Studio-kameraet til utsikten du vil ha, og kjør linjen for Command Bar fra steg 1 på nytt for det bildet.

Triggeren gjør ingenting

Sjekk at trigger-parten ligger rett inne i Workspace.CutsceneTriggers når spillet starter, at CanTouch er avhuket (ellers står det en advarsel i Output), og at attributten Cutscene er en string med navnet på en mappe i Workspace.Cutscenes. Å gå gjennom triggeren en gang til gjør ingenting, det er meningen.

Etter cutscenen blir kameraet stående på det siste bildet

CutscenePlayer stoppet med en feil før den rakk å gi kameraet tilbake, så se etter en rød feil fra den i Output. Et annet skript som hele tiden setter CameraType til Scriptable, kan også holde kameraet, for eksempel et menykamera som fortsatt er koblet til.

Lag det med RoCode

Hvis du ikke har lyst til å bygge dette for hånd, kan RoCode gjøre det i placet du har åpent. RoCode er en uavhengig AI-agent for Roblox Studio, ikke fra Roblox: du beskriver funksjonen i webchatten, og pluginen for Studio lager parten og skriptene i Explorer, så du trenger ikke kopiere kode fra et chatvindu.

Du skriver

Legg til en intro-cutscene: en mappe Cutscenes med en mappe Intro og bildene 1 til 3, tekst fra attributten Caption, svarte striper og en Skip-knapp, spilles én gang ved spillerens første spawn, serveren holder spilleren på plass, og til slutt kommer kameraet tilbake.

RoCode gjør
  • Kan først sjekke placet ditt med Search Scripts, for eksempel etter et meny- eller kameraskript som allerede setter CameraType, så de ikke kolliderer
  • Lager mappene og trigger-parten med Create Instance og setter attributter som Caption og MoveSeconds på partene
  • Skriver CutsceneService og CutscenePlayer med Create Script
  • Den er bedt om å sjekke hvert skript den skriver med Check Script, som kompilerer det i Studio uten å kjøre det, og den setter et angrepunkt før og etter hver runde med endringer

Plasser bilde-partene selv ved å flytte Studio-kameraet til hver utsikt, og be så om skriptene. Med plugin 3.9 eller nyere kan RoCode kjøre en kort playtest og lese feil, og med plugin 3.9.11 eller nyere kan den styre en testkarakter for å sjekke at spillet virker, men den tar ikke skjermbilder mens spillet kjører, så cutscenen ser du på selv. Rekkefølgen for å bygge et helt spill finner du på siden slik lager du et spill i Roblox med AI, system for system. Slik kobler RoCode seg til Studio.

Ofte stilte spørsmål

Hvordan får jeg en cutscene til å spilles når man kommer inn i spillet?

Kall mappen med bildene Intro i Workspace.Cutscenes, eller endre INTRO_CUTSCENE til navnet på mappen din. CutsceneService spiller den ved hver spillers første spawn på serveren. For å vise den bare aller første gang lagrer du et flagg i en data store og setter det bare etter at introen har startet, som beskrevet i Slik utvider du systemet.

Kan man lage en cutscene uten plugins?

Ja. Denne guiden bruker bare parts, attributter og to skript, og linjen for Command Bar plasserer hvert bilde nøyaktig der Studio-kameraet står. Plugins som Moon Animator er likevel nyttige for å animere karakterer som spiller i cutscenen.

Hvorfor beveger ikke kameraet seg i cutscenen?

Som regel ligger kamerakoden i et server-Script, mens bare et LocalScript kan flytte spillerens kamera, fordi hver enhet har sitt eget kamera. En annen vanlig årsak: CameraType er ikke Scriptable, og standard kameraskript i Roblox setter hele tiden kameraet tilbake til karakteren.

Hvordan hindrer jeg spilleren i å bevege seg under en cutscene?

Gjør HumanoidRootPart anchored på serveren mens den spilles, og fjern anchor etterpå, slik CutsceneService gjør. En anchored part beveger seg aldri på grunn av fysikk. WalkSpeed røres ikke, så det kolliderer ikke med et sprintskript eller en pass for fart.

Hvordan legger jeg til en Skip-knapp i en cutscene?

Legg en TextButton på cutscene-skjermen og koble til hendelsen Activated, som utløses av et klikk, et trykk eller A-knappen på en gamepad når knappen er valgt. Skip i CutscenePlayer setter et flagg som bildeløkken sjekker hver frame, velges automatisk for gamepad-spillere og ligger i sin egen ScreenGui med standardmarger, så kamerahullet på telefonen ikke dekker den. Styrespaken og hoppeknappen er skjult mens cutscenen pågår, så de står ikke ved siden av den.

Hvorfor er verden tom i cutscenen?

Med instance streaming slått på har spillerens enhet bare området nær karakteren hans. La serveren kalle player:RequestStreamAroundAsync for hvert bilde like før kameraet kommer dit, slik CutsceneService gjør. Roblox skriver at området da sannsynligvis, men ikke sikkert, blir lastet inn, så hold viktige bilder innenfor streaming-radiusen, eller bruk Player:AddReplicationFocus for et område som skal forbli lastet inn.

Kilder og videre lesing

Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.

Prøv RoCode i ditt eget spill.

Gratis credits hver dag, uten kort. Installer pluginen, beskriv en funksjon og se hva som dukker opp i Studio.