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
Hur en cutscene fungerar
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:
- Servern avgör att spelaren ska se en cutscene:
Introvid första spawn på servern, eller en annan när han rör vid en trigger-part. - 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
CutsceneEventbara till den här spelaren med id och listan över bilder. - 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.
- När den sista bilden är slut eller spelaren trycker på Skip lämnar den tillbaka kameran till karaktären och skickar
CutsceneEventmed samma id till servern. - 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.
| Del | Var den finns | Vad den gör |
|---|---|---|
Script CutsceneService | ServerScriptService | Avgör vem som ser vilken cutscene och när, läser bilderna, håller spelaren still och minns vem som redan sett vad. |
LocalScript CutscenePlayer | StarterPlayer, StarterPlayerScripts | Spelar upp cutscenen på spelarens skärm: fält, texter, Skip och kamerarörelse. Lämnar tillbaka kameran i slutet. |
RemoteEvent CutsceneEvent | ReplicatedStorage (CutsceneService skapar den) | Bär bilderna från servern till en spelare och tillbaka meddelandet "cutscenen är slut". |
Folder Cutscenes | Workspace | En mapp per cutscene, till exempel Intro, med bild-parts 1, 2, 3. |
Folder CutsceneTriggers | Workspace (valfritt) | Parts som startar en cutscene när en spelare rör vid dem. |
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.
- I Explorer, håll muspekaren över Workspace, tryck på knappen + och infoga en Folder med namnet
Cutscenes. Infoga inuti den en Folder med namnetIntro. Stora och små bokstäver i namnen spelar roll. - Flytta Studio-kameran till den första vyn du vill ha, som om du komponerade ett foto.
- Infoga en Part i Intro och byt namn på den till
1. - Ö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 ärCurrentCameravyn 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. - 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.
- Upprepa för nästa vyer, ge parts namnen
2,3och 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.
| Attribut | Typ | Standard | Vad det gör |
|---|---|---|---|
MoveSeconds | number | 3 | Hur 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. |
HoldSeconds | number | 1 | Hur många sekunder kameran står kvar på den här bilden efter ankomsten. |
Caption | string | ingen | Text 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.
-- 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ällning | Värde här | Vad 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_SECONDS | 3 | Hur länge en flygning varar om bilden saknar attributet MoveSeconds. |
DEFAULT_HOLD_SECONDS | 1 | Hur länge kameran står på en bild om den saknar attributet HoldSeconds. |
MAX_SHOTS | 30 | Det högsta bildnumret som CutsceneService letar efter i en cutscene. |
Vad resten av skriptet gör, i ordning:
- Läser bilderna på servern.
readShotssamlar 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.
playgö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.delayfryser upp spelaren efter cutscenens hela längd plus 2 sekunder, även om hans enhet aldrig svarade. - Varje cutscene en gång per server. Tabellen
seenminns 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.playOncereturnerar 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
- I Explorer, fäll ut StarterPlayer, håll muspekaren över StarterPlayerScripts och infoga en LocalScript med namnet
CutscenePlayer. - Ersätt dess innehåll med koden nedan.
-- 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.
| Del | Vad den gör |
|---|---|
ScreenGui Cutscene | Två 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 CutsceneControls | Innehå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_GUIS | Dö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. |
TouchControlsEnabled | På 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. |
updateCamera | Kö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. |
waitOrSkip | Väntar ut flygningens och bildens paustid och kontrollerar Skip-flaggan varje bildruta. |
play | Gö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-knappen | Activated 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.
- I Workspace, Cutscenes, infoga en Folder med namnet
Bridgeoch placera dess bilder som i steg 1, med namnen1och2. I raden för Command Bar skriver duBridgei stället förIntro. - Håll muspekaren över Workspace och infoga en Folder med namnet
CutsceneTriggers. - 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å. - Ge den ett attribut
Cutsceneav typen string och sätt värdet tillBridge: 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_STYLE | Hur flygningen känns |
|---|---|
Enum.EasingStyle.Sine (här) | Farten följer en sinuskurva, mjuk start och mjuk inbromsning. |
Enum.EasingStyle.Quad | Som Sine, men kurvan är lite skarpare. |
Enum.EasingStyle.Linear | Konstant 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.
| Guide | Problem | Den 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 annat | Focus 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 kameran | Spelaren 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 LocalScript | Inget 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å klienten | Med 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.
| Fuskaren försöker | Resultat |
|---|---|
| Hoppa över cutscenen eller inte spela den alls | Det 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 helst | Bara 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å kartan | Mö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 cutscenen | Det 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 remoten | Omö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
- Placera tre Intro-bilder med raden för Command Bar. Ge bild 1
Caption"Welcome to the village", bild 2MoveSeconds2.5 ochCaption"Find the bridge", och lämna bild 3 utan attribut. - 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å.
- 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.
- Gå in i BridgeTrigger: cutscenen Bridge spelas. Gå igenom den en gång till: ingenting händer.
- 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å.
- Låt
Workspace.StreamingEnabledvara 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). - 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.
- 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.
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.
- 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
- Roblox Creator Docs: Customize the camera (på engelska). en egen Camera för varje klient, Scriptable, CFrame och Focus
- Roblox Engine API: Camera (på engelska). CameraType, CameraSubject, Focus varje bildruta och föråldrade Interpolate
- Roblox Creator Docs: Control the user's camera (på engelska). BindToRenderStep ett prioritetssteg efter kameran
- Roblox Engine API: TweenService:GetValue (på engelska). mjukad alpha, begränsad mellan 0 och 1
- Roblox Engine API: ScreenGui.ScreenInsets (på engelska). varför None bara gäller innehåll som det inte finns något att trycka på i
- Roblox Creator Docs: Instance streaming (på engelska). påslaget som standard i nya places, och replication focus
- Roblox Creator Docs: Streaming techniques (på engelska). förladdning av ett område innan en händelse skickas
- Roblox Engine API: Player:RequestStreamAroundAsync (på engelska). en tillfällig förfrågan utan garanti
- Roblox Creator Docs: Remote events and callbacks (på engelska). meddelandekö och vilka tabeller som kan skickas
- Roblox Creator Docs: Network ownership, movement validation, and physics (på engelska). vad klienten kan göra med sin karaktär, inklusive förfalskning av Touched-händelser
- Roblox Engine API: Animator:LoadAnimation (på engelska). vilka animationer som replikeras
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.