Guide · Spelsystem

Hur gör man en cutscene i Roblox Studio

En cutscene i Roblox är en kamera som tar över kontrollen i några sekunder: den klipper eller flyger mjukt mellan bilder, visar en text och lämnar tillbaka kontrollen till spelaren. I den här guiden bygger vi en cutscene som du ställer in genom att placera osynliga parts där kameran ska stå, utan plugins. Servern avgör när spelaren ser den (vid första spawn eller när en trigger berörs), och spelarens enhet flyttar kameran, visar svarta fält och en Skip-knapp och lämnar tillbaka kameran.

Uppdaterad 20 november 202622 min läsningSkriven av

I korthet

Placera osynliga förankrade parts med namnen 1, 2, 3 i en mapp inuti Workspace.Cutscenes, var och en vänd dit kameran ska titta. Ett Script i ServerScriptService läser deras CFrame, håller spelaren still och skickar bilderna till den spelaren via en RemoteEvent. En LocalScript i StarterPlayerScripts sätter workspace.CurrentCamera.CameraType till Scriptable, flyttar kameran från bild till bild varje bildruta (mjukat med TweenService:GetValue) och sätter sedan tillbaka CameraType till Custom och CameraSubject till spelarens Humanoid.

  • Bara spelarens enhet kan styra kameran, så kamerakoden är en LocalScript. Servern avgör bara vem som ser vilken cutscene och när.
  • När kameran är Scriptable slutar Roblox att uppdatera Camera.Focus. Referensen säger att Focus ska uppdateras varje bildruta, annars kanske dynamisk belysning långt från det gamla fokuset inte renderas.
  • Camera:Interpolate är föråldrad. Roblox referens säger att kameran ska animeras med TweenService.
På den här sidan
  1. Hur det fungerar
  2. 1. Bilder
  3. 2. Serverskript
  4. 3. LocalScript
  5. 4. Trigger
  6. Kameradetaljer
  7. Gamla guider
  8. Skydd mot fusk
  9. 5. Kontroll
  10. Utbyggnad
  11. Common errors
  12. Med RoCode
  13. Vanliga frågor
  14. Källor och vidare läsning

Hur en cutscene fungerar

IllustrationEtt intro med två bilder i verklig hastighet: klipp till den första bilden, paus 1 sekund, flygning till bron på 2.5 sekunder, paus 1 sekund, sedan går kameran tillbaka till spelaren.

Varje spelares enhet har ett eget Camera-objekt, i workspace.CurrentCamera, så bara en LocalScript kan flytta det som spelaren ser. Att avgöra vem som ser vilken cutscene och när är serverns jobb. Guiden delar upp arbetet just så. En cutscene går till så här:

  1. Servern avgör att spelaren ska se en cutscene: Intro vid första spawn på servern, eller en annan när han rör vid en trigger-part.
  2. CutsceneService läser CFrame och inställningar från bild-parts, ber Roblox ladda området för den första bilden för den här spelaren, förankrar spelarens HumanoidRootPart så att han står still och skickar CutsceneEvent bara till den här spelaren med id och listan över bilder.
  3. CutscenePlayer på spelarens enhet visar svarta fält och Skip-knappen, döljer spelarlistan, ryggsäcken, hälsomätaren och pekkontrollerna, gör kameran Scriptable och flyttar den varje bildruta.
  4. När den sista bilden är slut eller spelaren trycker på Skip lämnar den tillbaka kameran till karaktären och skickar CutsceneEvent med samma id till servern.
  5. Servern tar bort förankringen från spelaren. Om meddelandet aldrig kom tar den ändå bort förankringen när cutscenens längd plus 2 sekunder har gått. Timern startar när servern skickar cutscenen, och vid en långsam inloggning kan enheten börja introt några sekunder senare, eftersom en LocalScript utanför ReplicatedFirst inte startar förrän spelet har laddats. Då kan spelaren röra sig igen innan introt är slut på hans skärm.
Vad cutscene-systemet består av
DelVar den finnsVad den gör
Script CutsceneServiceServerScriptServiceAvgör vem som ser vilken cutscene och när, läser bilderna, håller spelaren still och minns vem som redan sett vad.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsSpelar upp cutscenen på spelarens skärm: fält, texter, Skip och kamerarörelse. Lämnar tillbaka kameran i slutet.
RemoteEvent CutsceneEventReplicatedStorage (CutsceneService skapar den)Bär bilderna från servern till en spelare och tillbaka meddelandet "cutscenen är slut".
Folder CutscenesWorkspaceEn mapp per cutscene, till exempel Intro, med bild-parts 1, 2, 3.
Folder CutsceneTriggersWorkspace (valfritt)Parts som startar en cutscene när en spelare rör vid dem.
Explorer när cutscene-systemet är klart. Mapparna Bridge och CutsceneTriggers tillkommer i steg 4. När spelet startar lägger CutsceneService till en RemoteEvent med namnet 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: Placera kamerabilderna

Varje bild är en osynlig part. Kameran tar partens position och tittar åt samma håll som dess framsida, så att placera en bild är att placera kameran.

  1. I Explorer, håll muspekaren över Workspace, tryck på knappen + och infoga en Folder med namnet Cutscenes. Infoga inuti den en Folder med namnet Intro. Stora och små bokstäver i namnen spelar roll.
  2. Flytta Studio-kameran till den första vyn du vill ha, som om du komponerade ett foto.
  3. Infoga en Part i Intro och byt namn på den till 1.
  4. Öppna Command Bar (på fliken Script eller via Window, sedan Script) och kör workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. I redigeringsläget är CurrentCamera vyn du tittar genom, så parten hamnar exakt i den bilden. Hakparenteserna och citattecknen behövs eftersom ett namn som börjar med en siffra inte kan skrivas efter en punkt.
  5. I partens Properties, markera Anchored, avmarkera CanCollide, CanTouch och CanQuery och sätt Transparency till 1. Anchored hindrar den från att falla genom kartan; resten hindrar den från att störa spelare, utlösa beröringshändelser och blockera raycasts.
  6. Upprepa för nästa vyer, ge parts namnen 2, 3 och så vidare och ändra numret i raden för Command Bar. CutsceneService spelar bilderna i nummerordning och stannar vid det första saknade numret, så ett hål i numreringen avbryter cutscenen i förtid.

För att ändra en bild senare, flytta kameran till den nya vyn och kör samma rad med den bildens nummer. Med Transparency 1 är parts osynliga även i Studio, så välj dem i Explorer när du behöver dem.

Varje bild kan också ha tre valfria attribut. För att lägga till ett attribut, välj parten, scrolla ner i fönstret Properties till avsnittet Attributes, tryck på +, skriv namnet, välj typen och tryck på Save.

Valfria attribut på varje bild-part
AttributTypStandardVad det gör
MoveSecondsnumber3Hur många sekunder kameran flyger från föregående bild till den här. 0 ger ett hårt klipp. Bild 1 är alltid ett klipp, så attributet har ingen effekt där.
HoldSecondsnumber1Hur många sekunder kameran står kvar på den här bilden efter ankomsten.
CaptionstringingenText på det nedre fältet från det ögonblick kameran börjar flyga mot den här bilden. En bild utan Caption rensar texten.

Ett tal under 0 eller över 60, liksom ett attribut av fel typ, ersätts med standardvärdet.

Steg 2: Lägg till serverskriptet

Håll muspekaren över ServerScriptService, infoga ett Script med namnet CutsceneService och klistra in koden nedan. Inställningarna högst upp är raderna som du kan ändra.

Script i ServerScriptService med namnet CutsceneService
-- Script i ServerScriptService med namnet CutsceneService.
-- Avgör vem som ser vilken cutscene och när. Läser kamerabilderna från numrerade
-- parts i Workspace.Cutscenes, håller spelaren still och säger åt den
-- spelarens enhet att spela upp bilderna. Själva kameran kan bara flyttas på enheten.

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

-- Inställningar
local INTRO_CUTSCENE = "Intro" -- spelas en gång vid spelarens första spawn; "" för att stänga av
local DEFAULT_MOVE_SECONDS = 3 -- tid för flygningen till en bild om den saknar MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- tid på en bild om den saknar HoldSeconds
local MAX_SHOTS = 30

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

-- Det här skriptet skapar CutsceneEvent själv, så lägg inte till det för hand
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 för den cutscene som spelaren tittar 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

-- Bilderna är parts 1, 2, 3 ... i mappen med cutscenens namn
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,
			-- den första bilden är ett klipp, så kameran hoppar dit direkt
			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 -- den här cutscenen är redan slut
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- en cutscene i taget
	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 påslaget kanske spelarens enhet inte har området
	-- som bilden tittar på, och en förfrågan laddar området bara tillfälligt. Vi laddar
	-- den första bildens område nu (väntar upp till 2 sekunder), och varje följande bilds område
	-- 2 sekunder innan kameran flyger 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 -- spelaren lämnade medan området laddades
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- sekunder från nu tills flygningen till den här bilden börjar
	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
	-- Skyddsnät: vi fryser upp spelaren även om hans enhet aldrig svarade
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Returnerar true bara om cutscenen startade för den här spelaren
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

-- Spelarens enhet meddelar att cutscenen är slut eller överhoppad
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Trigger-parts: en beröring startar cutscenen från deras attribut Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Att koppla Touched till en part med CanTouch avstängt ger ett fel, så vi varnar bara
			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, håll även den nya karaktären still
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- redan konfigurerad
	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 -- alla som gick in medan skriptet väntade på Cutscenes
	onPlayerAdded(player)
end

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

CutsceneService skapar själv RemoteEvent CutsceneEvent så snart Workspace.Cutscenes dyker upp, så du behöver inte infoga något för hand i ReplicatedStorage. Om du redan har gjort en RemoteEvent med det namnet, ta bort den: LocalScript kan hitta din, och ingen lyssnar på den på servern.

Inställningarna högst upp i CutsceneService
InställningVärde härVad den ändrar
INTRO_CUTSCENE"Intro"Mappen i Workspace.Cutscenes som spelas vid spelarens första spawn på servern. Sätt "" för att inte ha något intro.
DEFAULT_MOVE_SECONDS3Hur länge en flygning varar om bilden saknar attributet MoveSeconds.
DEFAULT_HOLD_SECONDS1Hur länge kameran står på en bild om den saknar attributet HoldSeconds.
MAX_SHOTS30Det högsta bildnumret som CutsceneService letar efter i en cutscene.

Vad resten av skriptet gör, i ordning:

  • Läser bilderna på servern. readShots samlar CFrame och attribut från varje numrerad part i en lista. Spelarens enhet får listan, så den behöver inte själva parts.
  • En cutscene i taget. play gör ingenting medan spelaren redan tittar på en cutscene, eller om hans karaktär saknar Humanoid eller är död.
  • Varje cutscene har ett eget id. Enheten skickar tillbaka id:t när cutscenen är slut eller överhoppad, och bara ett matchande id fryser upp spelaren, så ett försenat meddelande från en tidigare cutscene kan inte avsluta en ny.
  • Håller spelaren still genom att förankra hans HumanoidRootPart, och förankrar den nya karaktären om spelaren respawnar mitt i en cutscene. Roblox referens säger att en förankrad part aldrig ändrar position på grund av gravitation, kollisioner eller annan fysik. WalkSpeed rörs inte, så det krockar inte med ett sprintskript eller ett fartpass. I slutet tar skriptet bort förankringen från root part, även om ett annat skript förankrade den, så förankra inte karaktärer på andra ställen medan en cutscene kan pågå.
  • Skyddsnät. task.delay fryser upp spelaren efter cutscenens hela längd plus 2 sekunder, även om hans enhet aldrig svarade.
  • Varje cutscene en gång per server. Tabellen seen minns för varje spelare vilka cutscenes som redan har startat, så introt upprepas inte vid respawn, och en cutscene från en trigger spelas en gång. playOnce returnerar true bara om cutscenen verkligen startade.
  • Konfigurerar varje spelare. Loopen över Players:GetPlayers() i slutet fångar upp alla som gick in medan skriptet väntade på mappen Cutscenes.

Bilderna går till spelaren med ett enda FireClient-anrop, som en lista med små tabeller. Roblox sida om remote events säger att man inte ska skicka en tabell som blandar numeriska och strängnycklar; den här listan har bara numeriska nycklar, och varje bild inuti har bara strängnycklar, vilket är formen som rekommenderas där.

Steg 3: Lägg till LocalScript som spelar upp den

  1. I Explorer, fäll ut StarterPlayer, håll muspekaren över StarterPlayerScripts och infoga en LocalScript med namnet CutscenePlayer.
  2. Ersätt dess innehåll med koden nedan.
LocalScript i StarterPlayerScripts med namnet CutscenePlayer
-- LocalScript i StarterPlayer > StarterPlayerScripts med namnet CutscenePlayer.
-- Spelar upp cutscenen som servern skickar: svarta fält, textrader, en Skip-knapp och
-- en kamera som flyger från bild till bild. Lämnar sedan tillbaka kameran till spelaren.

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 -- varje svart fält, som andel av skärmhöjden
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- hur många studs framför kameran Roblox ska rendera mest detaljerat
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: två svarta fält och en textrad, från kant till kant. Roblox rekommenderar
-- ScreenInsets None bara för sådant som ingen trycker på, så Skip nedan har en egen ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- hela 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 standardmarginaler, så kamerahålet täcker den inte
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å det nedre fältet, till höger
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 förblir stor nog att träffa på en liten mobil
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 aktuella flygningen: från en kamera-CFrame till nästa på ett givet antal sekunder
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Körs varje bildruta under cutscenen. Focus på en Scriptable kamera följer inte
-- något av sig självt, så den sätts också här.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- något återställde den, till exempel 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 spelas redan, så låt servern direkt frysa upp spelaren för den här
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Vi döljer spelarlistan, ryggsäcken och hälsomätaren och minns vad som 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å mobiler döljer vi spaken och hoppknappen, som sitter i de nedre hörnen
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- En handkontroll kan bara trycka på den markerade knappen, så vi markerar Skip för spelare med handkontroll
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Ett steg efter Roblox egen kamerauppdatering, som i Roblox kameraguide
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- varje flygning börjar där kameran är 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

	-- Vi lämnar tillbaka kameran till spelarens karaktär
	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 = ""
	-- Vi slår bara på igen det som den här cutscenen stängde av, resten rör vi inte
	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) -- servern fryser upp spelaren direkt
	busy = false
end

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

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

En LocalScript i StarterPlayerScripts kopieras till spelaren en gång, vid inloggning, och fortsätter köras efter att karaktären respawnar. Därför har båda ScreenGui ResetOnSpawn avstängt: om det slås på tar Roblox bort dem vid första respawn, och det här skriptet skapar dem inte igen. Remote-meddelanden som kommer innan skriptet har kopplat in sig på OnClientEvent köas och levereras efter anslutningen, så en spelare som spawnade snabbt ser ändå introt.

Vad varje del av CutscenePlayer gör
DelVad den gör
ScreenGui CutsceneTvå svarta fält, vart och ett 12% av skärmhöjden (BAR_HEIGHT), och en textrad på det nedre fältet. ScreenInsets None sträcker fälten ända ut till skärmens kanter, och DisplayOrder 10 ritar dem ovanpå ScreenGui med lägre DisplayOrder.
ScreenGui CutsceneControlsInnehåller bara Skip-knappen, till höger på det nedre fältet, med en UISizeConstraint som håller den på minst 64 gånger 32 pixlar, så att den är lätt att träffa på en mobil. Den har ScreenInsets som standard, och innehållet hamnar inte under Roblox knappar i toppfältet och kamerahål. Roblox rekommenderar None bara för innehåll som det inte finns något att trycka på i, så Skip kan inte bo i samma ScreenGui som fälten.
HIDDEN_CORE_GUISDöljer spelarlistan, ryggsäcken och hälsomätaren med SetCoreGuiEnabled, efter att först ha noterat med GetCoreGuiEnabled vilka som var påslagna, och slår i slutet bara på de som den själv stängde av. Om spelet döljer ryggsäcken på ett annat ställe förblir den dold, och ett skript som slår på dem under en cutscene, till exempel en huvudmeny, skrivs inte över.
TouchControlsEnabledPå mobiler och surfplattor sätter play GuiService.TouchControlsEnabled till false under cutscenen. Det döljer spaken och hoppknappen, som sitter i de nedre hörnen, på samma ställe som Skip, och i slutet kommer de tillbaka om de var påslagna.
updateCameraKörs varje bildruta medan cutscenen pågår. Räknar ut hur stor del av den aktuella flygningen som har gått, mjukar den med TweenService:GetValue, placerar kameran mellan två bilder med CFrame:Lerp och sätter Focus 30 studs framför kameran.
waitOrSkipVäntar ut flygningens och bildens paustid och kontrollerar Skip-flaggan varje bildruta.
playGör kameran Scriptable, spelar bilderna i ordning, lämnar sedan tillbaka kameran (CameraType Custom, CameraSubject är Humanoid), slår på core GUI och pekkontrollerna igen och skickar cutscenens id till servern. Om en andra cutscene kommer medan den första fortfarande spelas skickar den direkt tillbaka dess id, så att servern inte håller spelaren still för en cutscene som den här enheten inte visade.
Skip-knappenActivated utlöses av ett musklick, en tryckning eller knappen A på en handkontroll när knappen är markerad. För en spelare vars huvudsakliga inmatning är en handkontroll markerar play Skip i början av cutscenen och tar bort markeringen i slutet.

Ändra BAR_HEIGHT för att göra fälten tunnare eller tjockare, och EASING_STYLE för att ändra känslan i flygningarna (se Vad kamerakoden gör rätt). Textraden och Skip-knappen har TextScaled påslaget, så texten växer och krymper med skärmen.

Steg 4: En cutscene när en part berörs

Introt spelas av sig självt. För en cutscene på ett visst ställe på kartan, till exempel när spelaren första gången når bron, lägg till en andra cutscene och en trigger-part.

  1. I Workspace, Cutscenes, infoga en Folder med namnet Bridge och placera dess bilder som i steg 1, med namnen 1 och 2. I raden för Command Bar skriver du Bridge i stället för Intro.
  2. Håll muspekaren över Workspace och infoga en Folder med namnet CutsceneTriggers.
  3. Infoga i den en Part med namnet BridgeTrigger. Gör den så stor att spelare inte kan gå förbi utan att röra vid den, till exempel en hög, bred platta tvärs över vägen. Markera Anchored, avmarkera CanCollide och CanQuery, låt CanTouch vara markerad och sätt Transparency till 1. Avstängt CanQuery hindrar den osynliga plattan från att blockera raycasts, till exempel skott från guiden om vapen. Beröringshändelser styrs av CanTouch, inte CanQuery, så triggern fungerar ändå.
  4. Ge den ett attribut Cutscene av typen string och sätt värdet till Bridge: namnet på mappen som ska spelas.

CutsceneService kopplar Touched till varje part direkt inuti CutsceneTriggers när servern startar, så lägg till triggers i Studio och inte med ett skript under spelet. En trigger med CanTouch avstängt hoppas över med en varning i Output, eftersom Roblox ger ett fel när ett skript kopplar Touched till en sådan part.

Medan karaktären går genom parten utlöses Touched många gånger i rad. Tabellen seen och regeln "en cutscene i taget" gör det till en cutscene per spelare och server. En spelare som rör vid triggern under en annan cutscene ignoreras, och triggern förblir redo för honom.

Placera inte triggers på vägar. En sittande spelares HumanoidRootPart är svetsad vid sätet, och när en part i en svetsad grupp är förankrad förankrar Roblox även resten. Så en spelare som kör in i en trigger håller hela sitt fordon still, med passagerare, tills cutscenen är slut.

Vad kamerakoden gör rätt

Scriptable, sedan tillbaka till Custom

Roblox kameraskript flyttar och uppdaterar inte kameran medan CameraType är Scriptable, och det är just det som låter CutscenePlayer placera den. I slutet sätter den tillbaka CameraType till Custom och gör spelarens Humanoid till CameraSubject, som Roblox kameraskript följer som standard. Det körs även efter Skip, så spelaren blir aldrig kvar och stirrar på den sista bilden.

Två små kontroller håller cutscenen i kontroll medan den spelas. Om något sätter CameraType till ett annat värde mitt i en cutscene sätter funktionen som körs varje bildruta tillbaka Scriptable i nästa bildruta. Och workspace.CurrentCamera läser skriptet in på nytt i början av varje cutscene, eftersom Roblox skapar en ny Camera om den nuvarande någon gång tas bort.

Focus, varje bildruta

Camera.Focus talar om för motorn vilket område som ska prioriteras i arbete som belysning. Roblox kameraskript håller den på CameraSubject, men inte när kameran är Scriptable, och Roblox referens säger att den i det fallet ska uppdateras varje bildruta: dynamiskt ljus från objekt som PointLight kanske inte renderas långt från fokus. CutscenePlayer sätter den 30 studs framför kameran (FOCUS_DISTANCE). Öka talet om dina bilder tittar på något längre bort.

Funktionen körs via RunService:BindToRenderStep, varje bildruta före renderingen, ett prioritetssteg efter Roblox egen kamerauppdatering (Enum.RenderPriority.Camera.Value + 1). Den prioriteten används i Roblox kameraguide, så cutscenen placerar kameran efter att Roblox egen kamerakod har körts.

Mjukning med TweenService:GetValue

En tween på camera.CFrame skulle flytta kameran, men Focus måste ändå sättas varje bildruta, så CutscenePlayer flyttar kameran själv i samma funktion. För varje flygning räknar den ut hur stor andel av tiden som har gått (från 0 till 1), kör den genom TweenService:GetValue med en easing-stil och riktning och placerar kameran på den andelen av vägen mellan två bilder med CFrame:Lerp, som flyttar positionen i en rak linje och vrider mjukt. GetValue begränsar indata till mellan 0 och 1, så kameran stannar exakt på bilden när flygningens tid är slut.

Easing-stilar som passar en kameraflygning
EASING_STYLEHur flygningen känns
Enum.EasingStyle.Sine (här)Farten följer en sinuskurva, mjuk start och mjuk inbromsning.
Enum.EasingStyle.QuadSom Sine, men kurvan är lite skarpare.
Enum.EasingStyle.LinearKonstant fart, så varje flygning börjar och slutar i full fart.

Riktningen InOut: mjukningen tillämpas framåt under flygningens första halva och baklänges under den andra, så kameran accelererar från en bild och bromsar in mot nästa.

Streaming

I nya places är instance streaming påslaget: som standard håller spelarens enhet området runt hans karaktär, så en bild som tittar på andra änden av kartan kan visa en tom värld. CutsceneService ber Roblox ladda området för varje bild för den här spelaren med Player:RequestStreamAroundAsync: den första bildens område innan händelsen skickas, med en väntan på upp till 2 sekunder, och varje följande bilds område 2 sekunder innan kameran flyger dit.

Roblox skriver att området då troligen, men inte säkert, laddas, och att effekten är tillfällig. Håll viktiga bilder inom streamingradien eller använd Player:AddReplicationFocus på servern för ett område som ska förbli laddat tills du tar bort fokuset. Med streaming avstängt har enheten ändå hela kartan, och pcall runt varje förfrågan betyder att en misslyckad förfrågan inte kan stoppa cutscenen.

Vad som är fel i gamla cutscene-guider

Om du jämför den här guiden med en video eller ett foruminlägg är det här skillnaderna som spelar roll, och varför varje knep är ett problem.

Vanliga knep i cutscene-guider och vad den här guiden gör i stället
GuideProblemDen här guiden
Flyttar kameran med camera:Interpolate()Roblox har markerat Interpolate som föråldrad och rekommenderar att kameran animeras med TweenService.Mjukar varje flygning med TweenService:GetValue och placerar kameran varje bildruta.
Tweenar camera.CFrame och inget annatFocus blir kvar där kameraskripten lämnade den, nära karaktären, så dynamiskt ljus långt från den kanske inte renderas (Roblox referens för Camera.Focus).Sätter Focus varje bildruta i render step.
Lämnar inte tillbaka kameranSpelaren fastnar och tittar på den sista bilden.Sätter i slutet CameraType till Custom och CameraSubject till Humanoid, även efter Skip.
Startar cutscenen från Touched i en LocalScriptInget hindrar den från att upprepas vid varje beröring, och beslutet fattas på enheten som spelaren styr.Servern väljer spelaren och minns vem som redan har sett den.
Läser kamera-parts på klientenMed streaming påslaget kanske parts långt från karaktären inte finns på enheten än.Servern läser parts, skickar deras CFrame och begär området för varje bild strax innan kameran flyger dit.

Vad spelaren kan och inte kan ändra

Räkna med att en fuskare styr allt på sin enhet: han kan ändra eller ta bort CutscenePlayer och skicka CutsceneEvent med vilket värde som helst. För en cutscene betyder det nästan ingenting, så länge inget verkligt beror på den.

Vad en fuskare kan försöka och vad det leder till
Fuskaren försökerResultat
Hoppa över cutscenen eller inte spela den allsDet går: det är hans egen skärm. Ge aldrig en belöning för att "ha sett klart cutscenen".
Skicka CutsceneEvent med vilket värde som helstBara ett tal som matchar hans aktuella cutscene gör något, och allt det gör är att frysa upp honom tidigare.
Röra vid triggern från var som helst på kartanMöjligt: varje enhet styr sin egen karaktär, och Roblox säkerhetsdokumentation nämner förfalskning av Touched-händelser bland det som den kan göra. Han ser den cutscenen en gång, och inget mer händer.
Röra sig ändå under cutscenenDet finns inget att vinna. Frysningen hindrar ärliga spelare från att gå iväg mitt i en cutscene; det är ingen säkerhetskontroll.
Starta en cutscene för någon annan via remotenOmöjligt. Bara servern kan skicka CutsceneEvent till en spelare, och det enda enheten kan skicka tillbaka är "den här cutscenen är slut".

Om cutscenen leder till något verkligt, till exempel en dörr som sedan öppnas eller att en boss dyker upp, låt servern göra det med sin egen timer, inte när enheten meddelar att cutscenen är slut.

Steg 5: Kontrollera

  1. Placera tre Intro-bilder med raden för Command Bar. Ge bild 1 Caption "Welcome to the village", bild 2 MoveSeconds 2.5 och Caption "Find the bridge", och lämna bild 3 utan attribut.
  2. Tryck på Play (F5). Svarta fält dyker upp, kameran klipper till bild 1 med dess text, flyger på 2.5 sekunder till bild 2 och sedan på 3 sekunder till bild 3 utan text. Sedan går kameran tillbaka bakom karaktären, och spelarlistan dyker upp igen. Medan den spelas går det inte att gå.
  3. Stoppa testet, tryck på Play igen och tryck på Skip medan kameran flyger mot bild 2. Kameran går direkt tillbaka, och du kan gå direkt.
  4. Gå in i BridgeTrigger: cutscenen Bridge spelas. Gå igenom den en gång till: ingenting händer.
  5. Välj Server & Clients i listan för testläge, ange 2 klienter och tryck på Play. När Client 1 går in i triggern spelas cutscenen Bridge bara för Client 1, och Client 2 kan gå.
  6. Låt Workspace.StreamingEnabled vara påslaget och flytta en bild långt från spawnen. När kameran kommer fram ska omgivningen finnas där (troligen, men inte garanterat: se Streaming).
  7. För handkontroll, stoppa testet, tryck på Play, öppna Controller Emulator (fliken Emulation, sedan Controller) och gå in i BridgeTrigger med den emulerade handkontrollen: Skip ska vara markerad, så A hoppar över cutscenen. Om du använder Device Simulator i Studio (när vi kontrollerade den 15 oktober 2026 var det en beta: slå på den i File, Beta Features, New Device Simulator och starta om Studio), välj en mobil, vrid den till liggande läge och kontrollera att Skip inte hamnar under kamerahålet och är lätt att träffa, och att spaken och hoppknappen är dolda medan cutscenen pågår.
  8. Om du också har gjort en huvudmeny, tryck på Play, sedan på Play-knappen i menyn och låt introt spelas klart: efteråt ska spelarlistan synas på skärmen igen.

Ha fönstret Output öppet (menyn Window, sedan Output) hela tiden. När allt fungerar skriver de här skripten ingenting, så varje varning eller rött fel från CutsceneService eller CutscenePlayer är ett verkligt problem. Se Vanliga fel.

Hur du bygger ut systemet

Intro bara vid spelarens första besök

Tabellen seen lever en server, så en spelare som går in igen ser introt igen. För att bara visa det vid första besöket, spara en flagga, till exempel SeenIntro, tillsammans med spelarens övriga data via modulen PlayerData från DataStore-guiden. Låt INTRO_CUTSCENE vara som den är och ändra den del av onCharacterAdded i CutsceneService som hanterar introt: vänta tills PlayerData.Get(player) returnerar spelarens data, hoppa över introt om data.SeenIntro är true, och sätt data.SeenIntro = true bara när playOnce(player, INTRO_CUTSCENE) returnerade true. Starta inte introt från koden som laddar data: datan kan laddas innan karaktären spawnar, och utan karaktär gör play ingenting, och flaggan sparas för ett intro som ingen såg.

Karaktärer som agerar i cutscenen

Gör en animation i Animation Editor i Studio eller i ett tredjepartsplugin för animation, till exempel Moon Animator, som nämns i Roblox dokumentation, och spela den på en NPC-rigg i bilden när kameran kommer dit. Roblox referens för Animator säger att NPC-animationer bara replikeras om servern laddar och startar dem, så spela den från ett serverskript om alla spelare ska se NPC:n agera. Om du laddar och startar den i CutscenePlayer replikeras inte animationen, och det passar en cutscene som bara en spelare tittar på. Guiden om animationsskript visar hur du spelar en animation på en NPC från ett serverskript.

Dialoger

Texter passar för korta repliker som går av sig själva. För ett samtal där spelaren svarar och väljer alternativ, se guiden om NPC-dialoger.

Intro efter huvudmenyn

Guiden om huvudmenyn stänger av CharacterAutoLoads, så ingen spawnar förrän han trycker på Play. CutsceneService spelar introt vid spelarens första spawn, så med båda systemen spelas introt vid första spawn efter Play. Menyn slår på core GUI igen när karaktären dyker upp, och det kan hända när introt redan spelas, så spelarlistan kan synas under introt. CutscenePlayer slår bara på igen det som den själv dolde, så den rör inte menyns ändring, och efter introt förblir de påslagna. Knepet med Command Bar från guiden om huvudmenyn för att rikta kamera-parten är detsamma som i steg 1.

Kartflygning i början av en runda

För att starta en cutscene från ett annat serverskript, till exempel en flygning över kartan i början av en runda från guiden om rundsystem, lägg till en BindableEvent med namnet PlayCutscene i ServerStorage. I slutet av CutsceneService, koppla dess Event till funktionen play, och låt rundskriptet anropa den med varje spelare och cutscenens namn. play hoppar över kontrollen "en gång per server", så flygningen spelas varje runda.

Plugins för cutscenes

Plugins kan användas tillsammans med den här guiden. Om ett cutscene-plugin skriver ett eget kameraskript, kontrollera att det lämnar tillbaka kameran (CameraType Custom och CameraSubject) och sätter Focus medan kameran är Scriptable, och låt beslutet om vem som ser cutscenen ligga på servern, som i den här guiden.

Vanliga fel och lösningar

Öppna fönstret Output (menyn Window, sedan Output) innan du trycker på Play. De flesta cutscene-problem skriver antingen en varning där eller beror på ett namn som inte stämmer.

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

CutsceneService väntar på en mapp med namnet Cutscenes direkt i Workspace. Skapa den som i steg 1 och kontrollera stavningen och det stora C:et. Så länge den saknas skapar CutsceneService inte CutsceneEvent, så CutscenePlayer väntar också.

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

CutscenePlayer väntar på remoten som CutsceneService skapar. Kontrollera att CutsceneService är ett Script, inte en LocalScript, ligger direkt i ServerScriptService, inte är avstängt och att det inte finns något fel eller någon varning om Cutscenes från det i Output.

CutsceneService: no folder named Intro in Workspace.Cutscenes

Namnet i INTRO_CUTSCENE eller i triggerns attribut Cutscene matchar ingen mapp inuti Workspace.Cutscenes. Stora och små bokstäver i namnen spelar roll.

Ingenting spelas, och Output är tomt

Mappen har ingen part med namnet 1, eller så ligger dess parts inte direkt i den (till exempel inuti en Model). CutsceneService läser parts 1, 2, 3 i ordning och stannar vid det första saknade numret. Och kom ihåg att varje cutscene spelas en gång per spelare och server: stoppa testet och tryck på Play igen.

Kameran tittar åt fel håll

Kameran tittar åt samma håll som bild-partens framsida. Flytta Studio-kameran till vyn du vill ha och kör raden för Command Bar från steg 1 igen för den bilden.

Triggern gör ingenting

Kontrollera att trigger-parten ligger direkt inuti Workspace.CutsceneTriggers när spelet startar, att CanTouch är markerad (annars finns en varning i Output) och att dess attribut Cutscene är en sträng med namnet på en mapp i Workspace.Cutscenes. Att gå igenom triggern igen gör ingenting, det är avsiktligt.

Efter cutscenen stannar kameran på den sista bilden

CutscenePlayer stannade med ett fel innan den hann lämna tillbaka kameran, så leta efter ett rött fel från den i Output. Kameran kan också hållas kvar av ett annat skript som hela tiden sätter CameraType till Scriptable, till exempel en menykamera som fortfarande är kopplad.

Gör det med RoCode

Om du inte vill bygga det här för hand kan RoCode göra det i din öppna place. RoCode är en oberoende AI-agent för Roblox Studio, inte från Roblox: du beskriver funktionen i dess webbchatt, och dess Studio-plugin skapar parten och skripten i din Explorer, så du behöver inte kopiera kod från ett chattfönster.

Du skriver

Lägg till en intro-cutscene: en mapp Cutscenes med en mapp Intro och bilder 1 till 3, texter från attributet Caption, svarta fält och en Skip-knapp, spelas en gång vid spelarens första spawn, servern håller spelaren still, och i slutet kommer kameran tillbaka.

RoCode gör
  • Kan först gå igenom din place med Search Scripts, till exempel efter ett meny- eller kameraskript som redan sätter CameraType, så att de inte krockar
  • Skapar mapparna och trigger-parten med Create Instance och sätter attribut på parts, som Caption och MoveSeconds
  • Skriver CutsceneService och CutscenePlayer med Create Script
  • Det är instruerat att kontrollera varje skript det skriver med Check Script, som kompilerar det i Studio utan att köra det, och det sätter en ångrapunkt före och efter varje omgång ändringar

Placera bild-parts själv genom att flytta Studio-kameran till varje vy, och be sedan om skripten. Med plugin 3.9 eller nyare kan RoCode köra ett kort speltest och läsa felen, och med plugin 3.9.11 eller nyare kan det styra en testkaraktär för att kontrollera att spelet fungerar, men under spelet tar det inga skärmbilder, så cutscenen tittar du på själv. Ordningen i vilken ett helt spel byggs finns på sidan hur man gör ett spel i Roblox med AI, system för system. Hur RoCode ansluter till Studio.

Vanliga frågor

Hur får man en cutscene att spelas när man går in i spelet?

Ge mappen med bilder namnet Intro i Workspace.Cutscenes eller ändra INTRO_CUTSCENE till namnet på din mapp. CutsceneService spelar den vid varje spelares första spawn på servern. För att bara visa den vid allra första besöket, spara en flagga i ett data store och sätt den först efter att introt har startat, som beskrivs i avsnittet Hur du bygger ut systemet.

Kan man göra en cutscene utan plugins?

Ja. Den här guiden använder bara parts, attribut och två skript, och raden för Command Bar placerar varje bild exakt där Studio-kameran står. Plugins som Moon Animator är ändå praktiska för att animera karaktärer som agerar i cutscenen.

Varför rör sig inte kameran i cutscenen?

Oftast ligger kamerakoden i ett serverskript, men bara en LocalScript kan flytta spelarens kamera, eftersom varje enhet har sin egen kamera. En annan vanlig orsak: CameraType är inte Scriptable, och Roblox standardkameraskript drar hela tiden tillbaka kameran till karaktären.

Hur hindrar man spelaren från att röra sig under en cutscene?

Förankra hans HumanoidRootPart på servern medan den spelas, och ta bort förankringen efteråt, som CutsceneService gör. En förankrad part rör sig aldrig på grund av fysik. WalkSpeed rörs inte, så det krockar inte med ett sprintskript eller ett fartpass.

Hur lägger man till en Skip-knapp i en cutscene?

Lägg en TextButton på cutscene-skärmen och koppla in dess händelse Activated, som utlöses av ett klick, en tryckning eller knappen A på en handkontroll när knappen är markerad. Skip i CutscenePlayer sätter en flagga som bildloopen kontrollerar varje bildruta, markeras automatiskt för spelare med handkontroll och ligger i en egen ScreenGui med standardmarginaler, så att mobilens kamerahål inte täcker den. Spaken och hoppknappen är dolda medan cutscenen pågår, så de sitter inte bredvid den.

Varför är världen tom i cutscenen?

Med instance streaming påslaget har spelarens enhet bara området nära hans karaktär. Låt servern anropa player:RequestStreamAroundAsync för varje bild strax innan kameran flyger dit, som CutsceneService gör. Roblox skriver att området då troligen, men inte säkert, laddas, så håll viktiga bilder inom streamingradien eller använd Player:AddReplicationFocus för ett område som ska förbli laddat.

Källor och vidare läsning

Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.