Resumo
Coloque parts invisíveis e ancoradas chamadas 1, 2, 3 em uma pasta dentro de Workspace.Cutscenes, cada uma virada para onde a câmera deve olhar. Um Script no ServerScriptService lê os CFrames delas, segura o jogador parado e manda as tomadas para aquele jogador com um RemoteEvent. Um LocalScript no StarterPlayerScripts define workspace.CurrentCamera.CameraType como Scriptable, move a câmera de tomada em tomada a cada frame (com easing via TweenService:GetValue) e depois volta o CameraType para Custom e o CameraSubject para o Humanoid do jogador.
- Só o dispositivo do jogador consegue mover a câmera dele, então o código da câmera é um LocalScript. O servidor só decide quem vê qual cutscene e quando.
- Quando a câmera está em Scriptable, o Roblox para de atualizar
Camera.Focus. A referência diz para atualizar o Focus a cada frame, senão a iluminação dinâmica longe do foco antigo pode não renderizar. Camera:Interpolateestá obsoleto. A referência da Roblox diz para animar a câmera com TweenService no lugar dele.
Nesta página
Como uma cutscene funciona
O dispositivo de cada jogador tem o próprio objeto Camera, em workspace.CurrentCamera, então só um LocalScript consegue mudar o que aquele jogador vê (em inglês). Decidir quem vê qual cutscene, e quando, é trabalho do servidor. Este guia divide o trabalho desse jeito. Uma cutscene acontece assim:
- O servidor decide que um jogador deve ver uma cutscene: a
Introno primeiro spawn dele no servidor, ou outra quando ele toca em uma part de gatilho. - O CutsceneService lê os CFrames e as configurações das parts de tomada, pede ao Roblox para fazer o streaming da área da primeira tomada para aquele jogador, ancora o HumanoidRootPart do jogador para ele ficar parado e dispara o
CutsceneEventsó para aquele jogador, com um id e a lista de tomadas. - O CutscenePlayer, no dispositivo daquele jogador, mostra as barras pretas e o botão Skip, esconde a lista de jogadores, a mochila, a barra de vida e os controles de toque, deixa a câmera em Scriptable e a move a cada frame.
- Quando a última tomada termina, ou o jogador aperta Skip, ele devolve a câmera ao personagem e dispara o
CutsceneEventpara o servidor com o mesmo id. - O servidor desancora o jogador. Se essa mensagem nunca chega, ele desancora o jogador mesmo assim quando passa a duração da cutscene mais 2 segundos. Esse timer começa quando o servidor envia a cutscene, e em uma entrada lenta o dispositivo pode começar a intro alguns segundos depois, porque LocalScripts fora do ReplicatedFirst não rodam até o jogo carregar. Nesse caso o jogador pode voltar a se mexer antes de a intro terminar na tela dele.
| Peça | Onde fica | O que faz |
|---|---|---|
Script CutsceneService | ServerScriptService | Decide quem vê qual cutscene e quando, lê as tomadas, segura o jogador parado e lembra quem já viu o quê. |
LocalScript CutscenePlayer | StarterPlayer, StarterPlayerScripts | Toca uma cutscene na tela do jogador: barras, legendas, Skip e os movimentos da câmera. Devolve a câmera no final. |
RemoteEvent CutsceneEvent | ReplicatedStorage (o CutsceneService cria) | Leva as tomadas do servidor para um jogador, e traz de volta a mensagem "a cutscene terminou". |
Pasta Cutscenes | Workspace | Uma pasta por cutscene, como Intro, com as parts de tomada chamadas 1, 2, 3. |
Pasta CutsceneTriggers | Workspace (opcional) | Parts que começam uma cutscene quando um jogador toca nelas. |
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
Passo 1: Posicione as tomadas da câmera
Cada tomada é uma part invisível. A câmera pega a posição da part e olha na mesma direção da face da frente dela, então posicionar uma tomada é posicionar a câmera.
- No Explorer, passe o mouse sobre Workspace, clique no botão + e insira uma Folder chamada
Cutscenes. Dentro dela, insira uma Folder chamadaIntro. Os nomes diferenciam maiúsculas de minúsculas. - Voe com a câmera do Studio até a primeira vista que você quer, como se estivesse enquadrando uma foto.
- Insira uma Part na Intro e renomeie para
1. - Abra a Command Bar (na aba Script, ou em Window, depois Script) e rode
workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. No modo de edição,CurrentCameraé a vista pela qual você está olhando, então a part pula exatamente para essa tomada. Os colchetes e as aspas são necessários porque um nome que começa com dígito não pode vir depois de um ponto. - Nas Properties da part, marque Anchored, desmarque CanCollide, CanTouch e CanQuery, e defina Transparency como 1. Anchored impede que ela caia pelo mapa; as outras impedem que ela bloqueie jogadores, dispare eventos de toque e atrapalhe raycasts.
- Repita para as próximas vistas, chamando as parts de
2,3e assim por diante, e trocando o número na linha da Command Bar para combinar. O CutsceneService toca as tomadas em ordem numérica e para no primeiro número que falta, então um buraco termina a cutscene antes da hora.
Para mudar uma tomada depois, voe com a câmera até a nova vista e rode a mesma linha com o número dessa tomada. Com Transparency 1 as parts também ficam invisíveis no Studio, então selecione elas no Explorer quando precisar.
Cada tomada também pode ter três atributos opcionais. Para adicionar um, selecione a part, role até a seção Attributes da janela Properties, clique em +, digite o nome, escolha o tipo e clique em Save.
| Atributo | Tipo | Padrão | O que faz |
|---|---|---|---|
MoveSeconds | number | 3 | Segundos que a câmera leva para deslizar da tomada anterior até esta. 0 vira um corte. A tomada 1 é sempre um corte, então ela ignora isso. |
HoldSeconds | number | 1 | Segundos que a câmera fica nesta tomada depois de chegar. |
Caption | string | nenhum | Texto mostrado na barra de baixo a partir do momento em que a câmera começa a ir para esta tomada. Uma tomada sem Caption limpa o texto. |
Um número abaixo de 0 ou acima de 60, ou um atributo do tipo errado, volta para o padrão.
Passo 2: Adicione o script do servidor
Passe o mouse sobre ServerScriptService, insira um Script chamado CutsceneService e cole o código abaixo. As configurações no topo são as linhas feitas para você mudar.
-- Script no ServerScriptService chamado CutsceneService.
-- Decide quem vê qual cutscene e quando. Ele lê as tomadas da câmera das parts
-- numeradas em Workspace.Cutscenes, segura o jogador parado e manda o dispositivo
-- desse jogador tocar as tomadas. A câmera em si só pode ser movida no dispositivo.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Configurações
local INTRO_CUTSCENE = "Intro" -- toca uma vez quando o jogador nasce pela primeira vez; "" para nenhuma
local DEFAULT_MOVE_SECONDS = 3 -- tempo para deslizar até uma tomada sem MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- tempo parado em uma tomada sem HoldSeconds
local MAX_SHOTS = 30
local cutscenes = workspace:WaitForChild("Cutscenes")
local triggers = workspace:FindFirstChild("CutsceneTriggers")
-- Este script cria o CutsceneEvent sozinho, então não adicione um à mão
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 } = {} -- o id da cutscene que o jogador está assistindo
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
-- As tomadas são parts chamadas 1, 2, 3 ... dentro de uma pasta com o nome da cutscene
local function readShots(name: string): { Shot }
local shots: { Shot } = {}
local folder = cutscenes:FindFirstChild(name)
if not folder then
warn(`CutsceneService: no folder named {name} in Workspace.Cutscenes`)
return shots
end
for index = 1, MAX_SHOTS do
local part = folder:FindFirstChild(tostring(index))
if not (part and part:IsA("BasePart")) then
break
end
local caption = part:GetAttribute("Caption")
table.insert(shots, {
cframe = part.CFrame,
-- a primeira tomada é um corte, então a câmera pula direto para ela
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 -- esta cutscene já terminou
end
playing[player] = nil
setFrozen(player, false)
end
local function play(player: Player, name: string): boolean
if playing[player] then
return false -- uma cutscene de cada vez
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
-- Com o instance streaming ligado, o dispositivo do jogador pode não ter a área
-- para onde uma tomada olha, e um pedido só carrega a área por um tempo. Carregue
-- a área da primeira tomada agora (esperando até 2 segundos), e a de cada tomada
-- seguinte 2 segundos antes de a câmera começar a ir até ela.
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 -- o jogador saiu enquanto a área carregava
end
setFrozen(player, true)
cutsceneEvent:FireClient(player, id, shots)
local startsAt = 0 -- segundos daqui até a câmera começar a ir para esta tomada
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
-- Rede de segurança: solta o jogador mesmo se o dispositivo dele nunca responder
task.delay(startsAt + 2, finish, player, id)
return true
end
-- Retorna true só quando a cutscene começou para este jogador
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
-- O dispositivo do jogador avisa que a cutscene terminou ou foi pulada
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
if typeof(id) == "number" then
finish(player, id)
end
end)
-- Parts de gatilho: tocar em uma toca a cutscene que está no atributo Cutscene dela
if triggers then
for _, trigger in triggers:GetChildren() do
if not trigger:IsA("BasePart") then
continue
end
if not trigger.CanTouch then
-- Conectar o Touched em uma part com CanTouch desligado dá erro, então avisa no lugar
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) -- renasceu durante uma cutscene, então segura o novo personagem também
elseif INTRO_CUTSCENE ~= "" then
playOnce(player, INTRO_CUTSCENE)
end
end
local function onPlayerAdded(player: Player)
if seen[player] then
return -- já preparado
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 -- quem entrou enquanto este script esperava a Cutscenes
onPlayerAdded(player)
end
Players.PlayerRemoving:Connect(function(player: Player)
seen[player] = nil
playing[player] = nil
end)
O CutsceneService cria o RemoteEvent CutsceneEvent sozinho, assim que Workspace.Cutscenes existe, então não há nada para inserir à mão no ReplicatedStorage. Se você já fez um RemoteEvent com esse nome, apague: o LocalScript poderia achar o seu, que nada no servidor escuta.
| Configuração | Valor aqui | O que muda |
|---|---|---|
INTRO_CUTSCENE | "Intro" | A pasta em Workspace.Cutscenes que toca quando um jogador nasce pela primeira vez em um servidor. Defina como "" para não ter intro. |
DEFAULT_MOVE_SECONDS | 3 | Quanto tempo um deslize leva quando a tomada não tem o atributo MoveSeconds. |
DEFAULT_HOLD_SECONDS | 1 | Quanto tempo a câmera fica em uma tomada quando ela não tem o atributo HoldSeconds. |
MAX_SHOTS | 30 | O maior número de tomada que o CutsceneService procura em uma cutscene. |
O que o resto do script faz, em ordem:
- Lê as tomadas no servidor.
readShotsjunta o CFrame e os atributos de cada part numerada em uma lista. O dispositivo do jogador recebe essa lista, então nunca precisa das parts em si. - Uma cutscene de cada vez.
playnão faz nada enquanto o jogador já está assistindo uma, ou quando o personagem dele não tem Humanoid ou está morto. - Um id para cada cutscene. O dispositivo manda o id de volta quando a cutscene termina ou é pulada, e só o id certo solta o jogador, então uma mensagem atrasada de uma cutscene anterior não consegue terminar uma mais nova.
- Segura o jogador parado ancorando o HumanoidRootPart dele, e ancora o novo personagem também se o jogador renascer no meio da cutscene. A referência da Roblox diz que uma part ancorada nunca muda de posição por gravidade, colisões ou qualquer outra física. O WalkSpeed fica como está, então isso não briga com um script de corrida nem com um passe de velocidade. No fim ele desancora a root part mesmo que outro script a tenha ancorado, então não ancore personagens em outro lugar enquanto uma cutscene pode tocar.
- Uma rede de segurança.
task.delaysolta o jogador depois da duração total da cutscene mais 2 segundos, mesmo que o dispositivo dele nunca responda. - Toca cada cutscene uma vez por servidor. A tabela
seenlembra, para cada jogador, quais cutscenes já começaram, então a intro não se repete ao renascer e uma cutscene de gatilho toca uma vez.playOnceretorna true só quando a cutscene começou de verdade. - Prepara todo jogador. O loop sobre
Players:GetPlayers()no final pega quem entrou enquanto o script esperava a pasta Cutscenes.
As tomadas viajam até o jogador em uma única chamada de FireClient, como uma lista de tabelas pequenas. A página de remote events da Roblox diz para não enviar uma tabela que mistura chaves numéricas e chaves de texto; esta lista tem só chaves numéricas, e cada tomada dentro dela tem só chaves de texto, que é o formato que a página pede.
Passo 3: Adicione o LocalScript que toca a cutscene
- No Explorer, expanda StarterPlayer, passe o mouse sobre StarterPlayerScripts e insira um LocalScript chamado
CutscenePlayer. - Troque o conteúdo dele pelo código abaixo.
-- LocalScript em StarterPlayer > StarterPlayerScripts chamado CutscenePlayer.
-- Toca uma cutscene que o servidor envia: barras pretas, legendas, um botão Skip e a
-- câmera deslizando de tomada em tomada. Depois devolve a câmera ao jogador.
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 -- cada barra preta, como fração da altura da tela
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- studs à frente da câmera que o Roblox deve renderizar com mais detalhe
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 }
-- A tela da cutscene: duas barras pretas e uma legenda, de ponta a ponta. A Roblox diz para usar
-- ScreenInsets None só para coisas que ninguém aperta, então o Skip ganha a própria ScreenGui abaixo.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- cobre a tela inteira
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
-- O botão Skip mantém os insets padrão, então fica longe dos entalhes de câmera
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) -- na barra de baixo, à direita
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
-- Mantém o Skip grande o bastante para tocar em uma tela de celular pequena
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
-- O movimento atual: de um CFrame de câmera até o próximo em um certo número de segundos
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false
-- Roda a cada frame durante uma cutscene. O Focus de uma câmera Scriptable não segue
-- nada sozinho, então ele também é definido aqui.
local function updateCamera()
if camera.CameraType ~= Enum.CameraType.Scriptable then
camera.CameraType = Enum.CameraType.Scriptable -- algo resetou, como um 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
-- Já está tocando uma, então deixa o servidor soltar o jogador desta agora
cutsceneEvent:FireServer(id)
return
end
busy = true
skipRequested = false
-- Esconde a lista de jogadores, a mochila e a barra de vida, lembrando o que estava visível
local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
for _, coreGui in HIDDEN_CORE_GUIS do
wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
StarterGui:SetCoreGuiEnabled(coreGui, false)
end
-- No celular, esconde o analógico e o botão de pulo, que ficam nos cantos de baixo
local touchControlsWere = GuiService.TouchControlsEnabled
GuiService.TouchControlsEnabled = false
gui.Enabled = true
controls.Enabled = true
-- Um controle só aperta um botão selecionado, então seleciona o Skip para quem joga de controle
if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
GuiService.SelectedObject = skipButton
end
camera = workspace.CurrentCamera
camera.CameraType = Enum.CameraType.Scriptable
moveTo = camera.CFrame
-- Um passo depois da atualização de câmera do próprio Roblox, como faz o tutorial de câmera da Roblox
RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)
for _, shot in shots do
moveFrom = camera.CFrame -- começa cada movimento de onde a câmera estiver agora
moveTo = shot.cframe
moveStart = os.clock()
moveSeconds = shot.move
caption.Text = shot.caption
waitOrSkip(shot.move + shot.hold)
if skipRequested then
break
end
end
-- Devolve a câmera ao personagem do jogador
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 = ""
-- Religa só os que esta cutscene desligou, e deixa o resto como está
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) -- deixa o servidor soltar o jogador agora
busy = false
end
skipButton.Activated:Connect(function()
skipRequested = true
end)
cutsceneEvent.OnClientEvent:Connect(function(id: number, shots: { Shot })
play(id, shots)
end)
Um LocalScript no StarterPlayerScripts é copiado para o jogador uma vez, quando ele entra, e continua rodando quando o personagem renasce. Por isso as duas ScreenGuis têm ResetOnSpawn desligado: com ele ligado, o Roblox apagaria as duas no primeiro respawn, e este script não as criaria de novo. Mensagens de remote que chegam antes de o script se conectar ao OnClientEvent ficam na fila e são entregues quando ele se conecta, então um jogador que nasce rápido ainda vê a intro.
| Parte | O que faz |
|---|---|
A ScreenGui Cutscene | Duas barras pretas, cada uma com 12% da altura da tela (BAR_HEIGHT), com a legenda na barra de baixo. ScreenInsets None deixa as barras chegarem até as bordas da tela, e DisplayOrder 10 desenha elas por cima das ScreenGuis com DisplayOrder menor. |
A ScreenGui CutsceneControls | Guarda só o botão Skip, à direita da barra de baixo, com um UISizeConstraint que o mantém com pelo menos 64 por 32 pixels para continuar fácil de tocar no celular. Ela mantém o ScreenInsets padrão, que deixa o conteúdo longe dos botões da barra superior do Roblox e dos entalhes de câmera. A Roblox diz para usar None só em conteúdo sem nada para apertar, então o Skip não pode dividir a ScreenGui das barras. |
HIDDEN_CORE_GUIS | Esconde a lista de jogadores, a mochila e a barra de vida com SetCoreGuiEnabled, depois de anotar quais estavam ligadas com GetCoreGuiEnabled, e no fim religa só as que ele desligou. Um jogo que esconde a mochila em outro lugar continua com ela escondida, e um script que as liga durante a cutscene, como um menu principal, fica como está. |
TouchControlsEnabled | Em celulares e tablets, play define GuiService.TouchControlsEnabled como false durante a cutscene. Isso esconde o analógico e o botão de pulo, que ficam nos cantos de baixo, onde está o Skip, e eles voltam no final se estavam ligados. |
updateCamera | Roda a cada frame enquanto uma cutscene toca. Calcula quanto do movimento atual já passou, aplica o easing com TweenService:GetValue, coloca a câmera entre as duas tomadas com CFrame:Lerp e define o Focus 30 studs à frente da câmera. |
waitOrSkip | Espera o tempo de movimento e de parada de uma tomada, conferindo a flag do Skip a cada frame. |
play | Deixa a câmera em Scriptable, roda as tomadas em ordem, depois devolve a câmera (CameraType Custom, CameraSubject o Humanoid), religa as core GUIs e os controles de toque e dispara o id da cutscene para o servidor. Se uma segunda cutscene chega enquanto uma ainda está tocando, ele manda esse id de volta na hora, para o servidor não segurar o jogador parado por uma cutscene que este dispositivo não mostrou. |
| O botão Skip | Activated dispara com um clique do mouse, um toque, ou o botão A de um controle quando o botão está selecionado. Para um jogador cuja entrada preferida é um controle, play seleciona o Skip quando a cutscene começa e limpa a seleção no final. |
Mude BAR_HEIGHT para deixar as barras mais finas ou mais grossas, e EASING_STYLE para mudar a sensação dos movimentos (veja O que o código da câmera acerta). A legenda e o botão Skip usam TextScaled, então o texto deles cresce e diminui com a tela.
Passo 4: Toque uma cutscene quando o jogador encosta em uma part
A intro toca sozinha. Para uma cutscene em um lugar do seu mapa, como a primeira vez que o jogador chega a uma ponte, adicione uma segunda cutscene e uma part de gatilho.
- Em Workspace, Cutscenes, insira uma Folder chamada
Bridgee posicione as tomadas dela como no Passo 1, chamadas1e2. Na linha da Command Bar, useBridgeno lugar deIntro. - Passe o mouse sobre Workspace e insira uma Folder chamada
CutsceneTriggers. - Insira nela uma Part chamada
BridgeTrigger. Deixe ela grande o bastante para que os jogadores não consigam passar sem encostar, por exemplo uma placa alta e larga atravessando o caminho. Marque Anchored, desmarque CanCollide e CanQuery, deixe CanTouch marcado e defina Transparency como 1. CanQuery desligado impede que a placa invisível bloqueie raycasts, como os tiros do guia de arma (em inglês). Eventos de toque são controlados pelo CanTouch, não pelo CanQuery, então o gatilho continua funcionando. - Adicione a ela um atributo chamado
Cutscene, do tipo string, e defina o valor comoBridge: o nome da pasta que vai tocar.
O CutsceneService conecta o Touched em toda part direto dentro de CutsceneTriggers quando o servidor começa, então adicione gatilhos no Studio, não por um script com o jogo rodando. Um gatilho com CanTouch desligado é pulado com um aviso no Output, porque o Roblox dá erro quando um script conecta o Touched em uma part assim.
O Touched dispara muitas vezes seguidas enquanto um personagem atravessa uma part. A tabela seen e a regra de uma cutscene de cada vez transformam isso em uma cutscene por jogador por servidor. Um jogador que toca no gatilho enquanto outra cutscene está tocando é ignorado, e o gatilho continua pronto para ele.
Mantenha os gatilhos fora das estradas. O HumanoidRootPart de um jogador sentado está soldado ao assento, e quando uma part de um grupo soldado é ancorada, o Roblox ancora o resto junto. Um jogador que dirige até um gatilho, então, segura o veículo inteiro parado, passageiros incluídos, até a cutscene terminar.
O que o código da câmera acerta
Scriptable, depois de volta para Custom
Os scripts de câmera do Roblox não movem nem atualizam a câmera enquanto o CameraType é Scriptable, e é isso que deixa o CutscenePlayer posicioná-la. No fim ele volta o CameraType para Custom e faz do Humanoid do jogador o CameraSubject, que é o que os scripts de câmera do Roblox seguem por padrão. Isso roda depois de um Skip também, então o jogador nunca fica olhando para a última tomada.
Duas pequenas proteções mantêm a cutscene no comando enquanto ela toca. Se algo muda o CameraType no meio da cutscene, a função de cada frame volta para Scriptable no frame seguinte. E o script lê workspace.CurrentCamera de novo no começo de cada cutscene, porque o Roblox cria uma Camera nova se a atual for destruída.
Focus, a cada frame
Camera.Focus diz ao motor qual área priorizar em trabalhos como a iluminação. Os scripts de câmera do Roblox o mantêm no CameraSubject, mas não enquanto a câmera é Scriptable, e a referência da Roblox diz para atualizá-lo a cada frame nesse caso: a iluminação dinâmica de objetos como PointLights pode não renderizar longe do foco. O CutscenePlayer coloca o Focus 30 studs à frente da câmera (FOCUS_DISTANCE). Aumente esse valor se as suas tomadas olham para algo mais longe.
A função roda por RunService:BindToRenderStep, a cada frame antes de o frame ser desenhado, um passo de prioridade depois da atualização de câmera do próprio Roblox (Enum.RenderPriority.Camera.Value + 1). Essa é a prioridade que o tutorial de câmera da Roblox usa, então a cutscene posiciona a câmera depois que o código de câmera do Roblox já rodou.
Easing com TweenService:GetValue
Um tween em camera.CFrame moveria a câmera, mas o Focus ainda precisa ser definido a cada frame, então o CutscenePlayer faz o movimento sozinho na mesma função. Para cada movimento ele calcula a fração do tempo que já passou (de 0 a 1), passa esse valor por TweenService:GetValue com um estilo e uma direção de easing, e coloca a câmera nesse ponto entre as duas tomadas com CFrame:Lerp, que move a posição em linha reta e gira a rotação suavemente. GetValue limita a entrada entre 0 e 1, então a câmera para exatamente na tomada quando o tempo do movimento acaba.
| EASING_STYLE | Como o movimento parece |
|---|---|
Enum.EasingStyle.Sine (usado aqui) | A velocidade segue uma onda senoidal, para um começo e um fim suaves. |
Enum.EasingStyle.Quad | Como o Sine, com uma curva um pouco mais acentuada. |
Enum.EasingStyle.Linear | Velocidade constante, então cada movimento começa e para em velocidade máxima. |
A direção é InOut: o easing é aplicado para frente na primeira metade do movimento e ao contrário na segunda, então a câmera acelera ao sair de uma tomada e desacelera ao chegar na próxima.
Streaming
Places novos têm o instance streaming ligado: por padrão o dispositivo de um jogador guarda a área em volta do personagem dele, então uma tomada que olha para o outro lado do mapa pode mostrar um mundo vazio. O CutsceneService pede ao Roblox para fazer o streaming da área de cada tomada para aquele jogador com Player:RequestStreamAroundAsync: a área da primeira tomada antes de disparar o evento, esperando até 2 segundos, e a área de cada tomada seguinte 2 segundos antes de a câmera começar a ir até ela.
A Roblox diz que isso torna provável, não garantido, que a área esteja carregada, e que o efeito é temporário. Mantenha as tomadas importantes dentro do seu raio de streaming, ou use Player:AddReplicationFocus no servidor para uma área que precisa continuar carregada até você remover o foco. Com o streaming desligado, o dispositivo já tem o mapa inteiro, e o pcall em volta de cada pedido faz com que um pedido que falhe não consiga parar a cutscene.
O que tutoriais antigos de cutscene erram
Se você está comparando este guia com um vídeo ou um post de fórum, estas são as diferenças que importam, com o motivo de cada padrão ser um problema.
| O tutorial | O problema | Este guia |
|---|---|---|
Move a câmera com camera:Interpolate() | A Roblox marca o Interpolate como obsoleto e diz para animar a câmera com TweenService no lugar. | Aplica o easing em cada movimento com TweenService:GetValue e posiciona a câmera a cada frame. |
Faz tween de camera.CFrame e de mais nada | O Focus fica onde os scripts de câmera deixaram, perto do personagem, então a iluminação dinâmica longe dele pode não renderizar (referência Camera.Focus da Roblox). | Define o Focus a cada frame no render step. |
| Nunca devolve a câmera | O jogador fica preso olhando para a última tomada. | Define CameraType como Custom e CameraSubject como o Humanoid no final, depois de um Skip também. |
Começa a cutscene pelo Touched em um LocalScript | Nada impede que ela se repita a cada toque, e a decisão fica em um dispositivo que o jogador controla. | O servidor escolhe o jogador e lembra quem já viu. |
| Lê as parts da câmera no cliente | Com o streaming ligado, parts longe do personagem podem ainda não existir no dispositivo. | O servidor lê as parts, envia os CFrames delas e pede a área de cada tomada pouco antes de a câmera chegar lá. |
O que um jogador pode e não pode mudar
Suponha que um trapaceiro controla tudo no próprio dispositivo: ele pode editar ou apagar o CutscenePlayer e disparar o CutsceneEvent com qualquer valor. Para uma cutscene, isso importa muito pouco, desde que nada de real dependa dela.
| Um trapaceiro tenta | Resultado |
|---|---|
| Pular uma cutscene, ou nunca tocá-la | Permitido: a tela é dele. Nunca dê recompensa por "terminou a cutscene". |
Disparar o CutsceneEvent com qualquer valor | Só um número igual ao da cutscene atual dele faz alguma coisa, e tudo o que faz é soltá-lo mais cedo. |
| Tocar em um gatilho de qualquer lugar do mapa | Possível: cada dispositivo controla o próprio personagem, e a documentação de segurança da Roblox lista manipular eventos Touched entre as coisas que ele consegue fazer. Ele vê aquela cutscene uma vez, e nada mais acontece. |
| Se mexer durante a cutscene mesmo assim | Não ganha nada. O congelamento impede que jogadores honestos saiam andando no meio da cutscene; não é uma checagem de segurança. |
| Usar o remote para começar uma cutscene para outra pessoa | Não é possível. Só o servidor dispara o CutsceneEvent para um jogador, e a única mensagem que um dispositivo consegue mandar de volta é "esta cutscene terminou". |
Se uma cutscene leva a algo real, como uma porta que abre depois dela ou um chefe que aparece, deixe o servidor fazer isso com o próprio timer, não quando o dispositivo diz que a cutscene terminou.
Passo 5: Teste
- Posicione as três tomadas da Intro com a linha da Command Bar. Dê à tomada 1 a
Caption"Welcome to the village", dê à tomada 2MoveSeconds2.5 e aCaption"Find the bridge", e deixe a tomada 3 sem atributos. - Aperte Play (F5). Aparecem as barras pretas e a câmera corta para a tomada 1 com a legenda dela, desliza até a tomada 2 em 2,5 segundos, e depois até a tomada 3 em 3 segundos, sem legenda. Então a câmera volta para trás do seu personagem e a lista de jogadores reaparece. Você não consegue andar enquanto ela toca.
- Pare, aperte Play de novo e aperte Skip enquanto a câmera desliza até a tomada 2. A câmera volta na hora, e você já consegue andar.
- Ande até o BridgeTrigger: a cutscene Bridge toca. Atravesse ele de novo: nada acontece.
- Escolha Server & Clients no menu de modo de teste, defina 2 clients e aperte Play. Quando o Client 1 anda até o gatilho, a cutscene Bridge toca só no Client 1, e o Client 2 continua andando.
- Deixe
Workspace.StreamingEnabledligado e mova uma tomada para longe do spawn. O cenário deve estar lá quando a câmera chegar (provável, não garantido: veja Streaming). - Para controle, pare, aperte Play, abra o Controller Emulator (aba Emulation, depois Controller) e ande até o BridgeTrigger com o controle emulado: o Skip deve estar selecionado, então A pula. Se você usa o Device Simulator do Studio (um beta quando conferimos em 15 de outubro de 2026: ligue em File, Beta Features, New Device Simulator, depois reinicie o Studio), escolha um celular, vire para paisagem e confira que o Skip fica longe do entalhe da câmera e é fácil de tocar, e que o analógico e o botão de pulo ficam escondidos enquanto a cutscene toca.
- Se você também montou o menu principal, aperte Play, depois o botão Play do menu, e deixe a intro rodar até o fim: a lista de jogadores deve voltar para a tela depois.
Deixe a janela Output aberta (menu Window, depois Output) o tempo todo. Estes scripts não imprimem nada quando funcionam, então qualquer aviso ou erro vermelho do CutsceneService ou do CutscenePlayer é um problema real. Veja Erros comuns.
Indo além
Mostrar a intro só na primeira visita do jogador
A tabela seen dura um servidor, então um jogador que volta vê a intro de novo. Para mostrar só na primeira visita, salve uma flag como SeenIntro com o resto dos dados dele, usando o módulo PlayerData do tutorial de DataStore. Deixe o INTRO_CUTSCENE como está e mude a parte da intro no onCharacterAdded do CutsceneService: espere até PlayerData.Get(player) retornar os dados do jogador, pule a intro quando data.SeenIntro for true, e defina data.SeenIntro = true só quando playOnce(player, INTRO_CUTSCENE) retornar true. Não comece a intro pelo código que carrega os dados: os dados podem terminar de carregar antes de o personagem nascer, e play não faz nada sem personagem, então a flag seria salva para uma intro que ninguém viu.
Personagens atuando na cutscene
Faça a animação no Animation Editor do Studio, ou em um plugin de animação de terceiros como o Moon Animator, que a própria documentação da Roblox menciona, e toque ela em um rig de NPC na tomada quando a câmera chegar lá. A referência do Animator da Roblox diz que as animações de um NPC só replicam quando o servidor as carrega e começa, então toque a partir de um Script de servidor se todos os jogadores devem ver o NPC atuar. Carregada e iniciada no CutscenePlayer, a animação não é replicada, o que combina com uma cutscene que só um jogador está assistindo. O guia de script de animação mostra como tocar uma em um NPC a partir de um Script de servidor.
Diálogo
Legendas servem para falas curtas que tocam sozinhas. Para uma conversa em que o jogador responde e escolhe opções, veja o guia de diálogo de NPC.
Uma intro depois do menu principal
O guia de menu principal desliga o CharacterAutoLoads, então ninguém nasce até apertar Play. O CutsceneService toca a intro no primeiro spawn do jogador, então com os dois sistemas a intro toca no primeiro spawn depois do Play. O menu religa as core GUIs assim que o personagem aparece, o que pode acontecer com a intro já tocando, então a lista de jogadores pode aparecer durante a intro. O CutscenePlayer religa só as que ele mesmo escondeu, então deixa a mudança do menu como está e elas continuam ligadas depois da intro. O truque da Command Bar do guia de menu principal para mirar uma part de câmera é o mesmo que o Passo 1 usa.
Um voo pelo mapa no começo de um round
Para começar uma cutscene a partir de outro script de servidor, como um voo pelo mapa quando começa um round do guia de sistema de rounds, adicione um BindableEvent chamado PlayCutscene ao ServerStorage. No fim do CutsceneService, conecte o Event dele à função play, e faça o script de round disparar o evento com cada jogador e o nome da cutscene. play pula a checagem de uma vez por servidor, então o voo toca a cada round.
Plugins de cutscene
Tudo bem usar plugins junto com este guia. Se um plugin de cutscene escreve o próprio script de câmera, confira se ele devolve a câmera (CameraType Custom e um CameraSubject) e define o Focus enquanto a câmera é Scriptable, e deixe a decisão de quem vê a cutscene no servidor, como neste guia.
Erros comuns e como resolver
Abra a janela Output (menu Window, depois Output) antes de apertar Play. A maioria dos problemas de cutscene ou imprime um aviso ali ou vem de um nome que não bate.
Infinite yield possible on 'Workspace:WaitForChild("Cutscenes")'
O CutsceneService está esperando uma pasta chamada Cutscenes direto no Workspace. Crie ela como no Passo 1 e confira a grafia e o C maiúsculo. Enquanto ela não existir, o CutsceneService não cria o CutsceneEvent, então o CutscenePlayer espera também.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("CutsceneEvent")'
O CutscenePlayer está esperando o remote que o CutsceneService cria. Confira se o CutsceneService é um Script, não um LocalScript, direto dentro do ServerScriptService, se ele não está desativado e se o Output não mostra nenhum erro ou aviso de Cutscenes vindo dele.
CutsceneService: no folder named Intro in Workspace.Cutscenes
O nome em INTRO_CUTSCENE, ou no atributo Cutscene de um gatilho, não bate com nenhuma pasta dentro de Workspace.Cutscenes. Os nomes diferenciam maiúsculas de minúsculas.
Nada toca, e o Output não mostra nada
A pasta não tem uma part chamada 1, ou as parts não estão direto dentro dela (por exemplo, estão dentro de um Model). O CutsceneService lê as parts chamadas 1, 2, 3 em ordem e para no primeiro número que falta. Lembre também que cada cutscene toca uma vez por jogador por servidor: pare o teste e aperte Play de novo.
A câmera aponta para o lado errado
A câmera olha na mesma direção da face da frente da part de tomada. Voe com a câmera do Studio até a vista que você quer e rode de novo a linha da Command Bar do Passo 1 para essa tomada.
O gatilho não faz nada
Confira se a part de gatilho está direto dentro de Workspace.CutsceneTriggers quando o jogo começa, se o CanTouch está marcado (o Output mostra um aviso se não estiver) e se o atributo Cutscene dela é uma string com o nome de uma pasta em Workspace.Cutscenes. Atravessar uma segunda vez não faz nada, de propósito.
A câmera fica na última tomada depois da cutscene
O CutscenePlayer parou com um erro antes de conseguir devolver a câmera, então procure um erro vermelho dele no Output. Outro script que fica definindo o CameraType como Scriptable, como uma câmera de menu que ainda está conectada, também pode segurar a câmera.
Crie com o RoCode
Se você prefere não montar isso à mão, o RoCode pode construir tudo no jogo que você tem aberto. O RoCode é um agente de IA independente para Roblox Studio, não feito pela Roblox: você descreve o recurso no chat na web, e o plugin dele para o Studio cria a part e os scripts no seu Explorer, então você não fica copiando código de uma janela de chat.
Adicione uma cutscene de intro: uma pasta Cutscenes com uma pasta Intro de tomadas chamadas 1 a 3, legendas vindas de um atributo Caption, barras pretas e um botão Skip, tocada uma vez quando o jogador nasce pela primeira vez, com o servidor segurando o jogador parado e a câmera devolvida no final.
- Pode olhar o seu jogo antes com Search Scripts, por exemplo atrás de um script de menu ou de câmera que já define
CameraType, para os dois não brigarem - Cria as pastas e a part de gatilho com Create Instance, e define nas parts atributos como Caption e MoveSeconds
- Escreve o CutsceneService e o CutscenePlayer com Create Script
- É instruído a checar cada script que escreve com Check Script, que compila o script dentro do Studio sem rodá-lo, e cria um ponto de desfazer antes e depois de cada lote de mudanças
Posicione as parts de tomada você mesmo, voando com a câmera do Studio até cada vista, e depois peça os scripts. Com o plugin 3.9 ou mais recente, o RoCode pode rodar um teste curto e ler os erros, e com o plugin 3.9.11 ou mais recente ele pode controlar um personagem de teste para conferir se o jogo funciona, mas ele não tira screenshots enquanto o jogo roda, então assista a cutscene você mesmo. Para a ordem em que montar um jogo inteiro, veja como fazer um jogo de Roblox com IA, sistema por sistema. Como o RoCode se conecta ao Studio.
Perguntas frequentes
Como fazer uma cutscene tocar quando o jogador entra no jogo?
Chame uma pasta de tomadas de Intro em Workspace.Cutscenes, ou mude o INTRO_CUTSCENE para o nome da sua pasta. O CutsceneService toca ela no primeiro spawn de cada jogador em um servidor. Para mostrar só na primeiríssima visita de alguém, salve uma flag em um data store e defina ela só depois que a intro começou, como explicado em Indo além.
Dá para fazer uma cutscene sem plugin?
Sim. Este guia usa só parts, atributos e dois scripts, e a linha da Command Bar coloca cada tomada exatamente onde a câmera do Studio está. Plugins como o Moon Animator ainda ajudam para animar personagens que atuam na cutscene.
Por que a câmera não se mexe na minha cutscene?
Normalmente o código da câmera está em um Script de servidor, mas só um LocalScript consegue mover a câmera de um jogador, porque cada dispositivo tem a sua. A outra causa comum é o CameraType não estar em Scriptable, então os scripts de câmera padrão do Roblox ficam levando a câmera de volta para o personagem.
Como impedir o jogador de andar durante uma cutscene?
Ancore o HumanoidRootPart dele no servidor enquanto ela toca e desancore depois, como faz o CutsceneService. Uma part ancorada nunca se move pela física. Isso não mexe no WalkSpeed, então não briga com um script de corrida nem com um passe de velocidade.
Como colocar um botão de pular na cutscene?
Coloque um TextButton na tela da cutscene e conecte o evento Activated dele, que dispara com um clique, um toque, ou o botão A de um controle quando o botão está selecionado. O Skip do CutscenePlayer liga uma flag que o loop de tomadas confere a cada frame, é selecionado automaticamente para quem joga de controle, e fica na própria ScreenGui com os insets padrão para o entalhe da câmera do celular não cobrir ele. O analógico e o botão de pulo ficam escondidos enquanto a cutscene toca, então não ficam ao lado dele.
Por que o mundo aparece vazio na minha cutscene?
Com o instance streaming ligado, o dispositivo de um jogador só tem a área perto do personagem dele. Faça o servidor chamar player:RequestStreamAroundAsync para cada tomada pouco antes de a câmera chegar lá, como faz o CutsceneService. A Roblox diz que isso torna provável, não garantido, que a área esteja carregada, então mantenha as tomadas importantes dentro do seu raio de streaming, ou use Player:AddReplicationFocus para uma área que precisa continuar carregada.
Fontes e leitura extra
- Roblox Creator Docs: Customize the camera (em inglês). a Camera própria de cada cliente, Scriptable, CFrame e Focus
- Roblox Engine API: Camera (em inglês). CameraType, CameraSubject, Focus a cada frame, e o Interpolate obsoleto
- Roblox Creator Docs: Control the user's camera (em inglês). BindToRenderStep um passo de prioridade depois da câmera
- Roblox Engine API: TweenService:GetValue (em inglês). alpha com easing, limitado entre 0 e 1
- Roblox Engine API: ScreenGui.ScreenInsets (em inglês). por que None é só para conteúdo sem nada para apertar
- Roblox Creator Docs: Instance streaming (em inglês). ligado por padrão em places novos, e o replication focus
- Roblox Creator Docs: Streaming techniques (em inglês). carregar uma área antes de disparar um evento
- Roblox Engine API: Player:RequestStreamAroundAsync (em inglês). um pedido temporário, sem garantia
- Roblox Creator Docs: Remote events and callbacks (em inglês). mensagens na fila e quais tabelas podem ser enviadas
- Roblox Creator Docs: Network ownership, movement validation, and physics (em inglês). o que um cliente pode fazer com o próprio personagem, incluindo manipular eventos Touched
- Roblox Engine API: Animator:LoadAnimation (em inglês). quais animações replicam
Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 14 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.