Tutorial · Sistemas de juego

Cómo hacer una cinemática en Roblox Studio

Una cinemática en Roblox es la cámara tomando el control unos segundos: corta o se desliza entre tomas, muestra un subtítulo y te devuelve el control. Esta guía construye una que preparas colocando partes invisibles donde debe estar la cámara, sin ningún plugin. El servidor decide cuándo la ve un jugador (cuando aparece por primera vez o cuando toca un trigger), y el dispositivo del jugador mueve la cámara, muestra barras negras y un botón Skip, y devuelve la cámara.

Actualizado el 14 de noviembre de 202625 min de lecturaEscrito por

La respuesta corta

Coloca partes invisibles y ancladas llamadas 1, 2, 3 en una carpeta dentro de Workspace.Cutscenes, cada una mirando hacia donde debe mirar la cámara. Un Script en ServerScriptService lee sus CFrames, deja quieto al jugador y le envía las tomas con un RemoteEvent. Un LocalScript en StarterPlayerScripts pone workspace.CurrentCamera.CameraType en Scriptable, mueve la cámara de toma en toma cada frame (con easing usando TweenService:GetValue) y después vuelve a poner CameraType en Custom y CameraSubject en el Humanoid del jugador.

  • Solo el dispositivo del jugador puede mover su cámara, así que el código de la cámara es un LocalScript. El servidor solo decide quién ve cada cinemática y cuándo.
  • Cuando la cámara es Scriptable, Roblox deja de actualizar Camera.Focus. Su referencia dice que actualices Focus cada frame, o la iluminación dinámica lejos del foco anterior puede no renderizarse.
  • Camera:Interpolate está obsoleto. La referencia de Roblox dice que animes la cámara con TweenService.
En esta página
  1. Cómo funciona
  2. 1. Coloca las tomas
  3. 2. Script del servidor
  4. 3. LocalScript
  5. 4. Trigger de toque
  6. Detalles de cámara
  7. Tutoriales viejos
  8. Límites de exploits
  9. 5. Pruébala
  10. Ampliarla
  11. Errores comunes
  12. Con RoCode
  13. Preguntas frecuentes
  14. Fuentes y lecturas

Cómo funciona una cinemática

IlustraciónUna intro de dos tomas a velocidad real: un corte a la primera toma, una pausa de 1 segundo, un deslizamiento de 2.5 segundos hasta el puente, otra pausa de 1 segundo y la cámara vuelve al jugador.

El dispositivo de cada jugador tiene su propio objeto Camera, en workspace.CurrentCamera, así que solo un LocalScript puede mover lo que ve ese jugador (en inglés). Decidir quién ve cada cinemática, y cuándo, es trabajo del servidor. Esta guía reparte el trabajo así. Una cinemática va de esta forma:

  1. El servidor decide que un jugador debe ver una cinemática: la Intro en su primera aparición en el servidor, u otra cuando toca una parte trigger.
  2. CutsceneService lee los CFrames y ajustes de las partes de las tomas, le pide a Roblox que cargue para ese jugador la zona de la primera toma, ancla el HumanoidRootPart del jugador para que no se mueva y dispara CutsceneEvent solo a ese jugador, con un id y la lista de tomas.
  3. CutscenePlayer, en el dispositivo de ese jugador, muestra las barras negras y el botón Skip, oculta la lista de jugadores, la mochila, la barra de vida y los controles táctiles, pone la cámara en Scriptable y la mueve cada frame.
  4. Cuando termina la última toma, o el jugador pulsa Skip, devuelve la cámara al personaje y dispara CutsceneEvent al servidor con el mismo id.
  5. El servidor desancla al jugador. Si ese mensaje nunca llega, lo desancla de todos modos cuando pasa la duración de la cinemática más 2 segundos. Ese temporizador empieza cuando el servidor envía la cinemática, y si el jugador tarda en entrar, el dispositivo puede empezar la intro unos segundos después, porque los LocalScripts fuera de ReplicatedFirst no se ejecutan hasta que el juego ha cargado. En ese caso el jugador puede volver a moverse antes de que la intro termine en su pantalla.
Las piezas del sistema de cinemáticas
PiezaDónde vaQué hace
Script CutsceneServiceServerScriptServiceDecide quién ve cada cinemática y cuándo, lee las tomas, deja quieto al jugador y recuerda quién vio qué.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsReproduce una cinemática en la pantalla del jugador: barras, subtítulos, Skip y los movimientos de cámara. Al final devuelve la cámara.
RemoteEvent CutsceneEventReplicatedStorage (lo crea CutsceneService)Lleva las tomas del servidor a un jugador, y de vuelta el mensaje de "la cinemática terminó".
Folder CutscenesWorkspaceUna carpeta por cinemática, como Intro, con las partes de las tomas llamadas 1, 2, 3.
Folder CutsceneTriggersWorkspace (opcional)Partes que empiezan una cinemática cuando un jugador las toca.
El Explorer cuando el sistema de cinemáticas está terminado. La carpeta Bridge y CutsceneTriggers llegan en el Paso 4. Cuando el juego se ejecuta, CutsceneService añade un RemoteEvent llamado CutsceneEvent a ReplicatedStorage.
Workspace
  Cutscenes Folder new
    Intro Folder new
      1 Part new
      2 Part new
      3 Part new
    Bridge Folder new
      1 Part new
      2 Part new
  CutsceneTriggers Folder new
    BridgeTrigger Part new
ServerScriptService
  CutsceneService Script new
StarterPlayer
  StarterPlayerScripts
    CutscenePlayer LocalScript new

Paso 1: Coloca las tomas de cámara

Cada toma es una parte invisible. La cámara toma la posición de la parte y mira hacia el mismo lado que su cara frontal, así que colocar una toma es colocar la cámara.

  1. En el Explorer, pasa el cursor sobre Workspace, haz clic en el botón + e inserta un Folder llamado Cutscenes. Dentro, inserta un Folder llamado Intro. Los nombres distinguen mayúsculas y minúsculas.
  2. Mueve la cámara de Studio hasta la primera vista que quieres, como si encuadraras una foto.
  3. Inserta una Part en Intro y cámbiale el nombre a 1.
  4. Abre la Command Bar (en la pestaña Script, o en Window y luego Script) y ejecuta workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. En modo edición, CurrentCamera es la vista que estás mirando, así que la parte salta justo a esa toma. Los corchetes y las comillas hacen falta porque un nombre que empieza con un número no puede ir después de un punto.
  5. En las Properties de la parte, marca Anchored, desmarca CanCollide, CanTouch y CanQuery, y pon Transparency en 1. Anchored evita que se caiga del mapa; las demás evitan que bloquee a los jugadores, dispare eventos de toque y estorbe a los raycasts.
  6. Repite con las siguientes vistas, llamando a las partes 2, 3 y así, y cambiando el número en la línea de la Command Bar para que coincida. CutsceneService reproduce las tomas en orden numérico y se detiene en el primer número que falta, así que un hueco termina la cinemática antes de tiempo.

Para cambiar una toma después, mueve la cámara a la nueva vista y ejecuta la misma línea con el número de esa toma. Con Transparency 1 las partes también son invisibles en Studio, así que selecciónalas en el Explorer cuando las necesites.

Cada toma puede tener también tres atributos opcionales. Para añadir uno, selecciona la parte, baja hasta la sección Attributes de la ventana Properties, haz clic en +, escribe el nombre, elige el tipo y haz clic en Save.

Atributos opcionales en cada parte de toma
AtributoTipoPor defectoQué hace
MoveSecondsnumber3Segundos que tarda la cámara en deslizarse desde la toma anterior hasta esta. 0 lo convierte en un corte. La toma 1 siempre es un corte, así que lo ignora.
HoldSecondsnumber1Segundos que la cámara se queda en esta toma después de llegar.
CaptionstringningunoTexto que se muestra en la barra de abajo desde que la cámara empieza a moverse hacia esta toma. Una toma sin Caption borra el texto.

Un número menor que 0 o mayor que 60, o un atributo del tipo equivocado, vuelve al valor por defecto.

Paso 2: Añade el script del servidor

Pasa el cursor sobre ServerScriptService, inserta un Script llamado CutsceneService y pega el código de abajo. Los ajustes de arriba son las líneas que están pensadas para que las cambies.

Script en ServerScriptService llamado CutsceneService
-- Script en ServerScriptService llamado CutsceneService.
-- Decide quién ve cada cinemática y cuándo. Lee las tomas de cámara de las partes
-- numeradas en Workspace.Cutscenes, deja quieto al jugador y le dice al dispositivo
-- de ese jugador que reproduzca las tomas. La cámara solo se puede mover en el dispositivo.

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

-- Ajustes
local INTRO_CUTSCENE = "Intro" -- se reproduce una vez cuando un jugador aparece por primera vez; "" para ninguna
local DEFAULT_MOVE_SECONDS = 3 -- tiempo para deslizarse a una toma que no tiene MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- tiempo que se queda en una toma que no tiene HoldSeconds
local MAX_SHOTS = 30

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

-- Este script crea CutsceneEvent por sí mismo, así que no añadas uno a mano
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 } = {} -- el id de la cinemática que está viendo el jugador
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

-- Las tomas son partes llamadas 1, 2, 3 ... dentro de una carpeta con el nombre de la cinemática
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,
			-- la primera toma es un corte, así que la cámara salta directo a ella
			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 cinemática ya terminó
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- una cinemática a la 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

	-- Con instance streaming activado, el dispositivo del jugador puede no tener la zona
	-- que mira una toma, y una petición solo carga una zona por un tiempo. Carga la zona
	-- de la primera toma ahora (esperando hasta 2 segundos), y la de cada toma siguiente
	-- 2 segundos antes de que la cámara empiece a moverse hacia ella.
	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 -- el jugador salió mientras cargaba la zona
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- segundos desde ahora hasta que la cámara empieza a moverse a esta toma
	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
	-- Red de seguridad: libera al jugador aunque su dispositivo nunca responda
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Devuelve true solo cuando la cinemática empezó para este jugador
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

-- El dispositivo del jugador avisa que la cinemática terminó o se saltó
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Partes trigger: tocar una reproduce la cinemática indicada en su atributo Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Conectar Touched en una parte con CanTouch desactivado da error, así que avisa en su 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) -- reapareció durante una cinemática, así que deja quieto también al nuevo personaje
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- ya está 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 -- quien entró mientras este script esperaba a Cutscenes
	onPlayerAdded(player)
end

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

CutsceneService crea él mismo el RemoteEvent CutsceneEvent, en cuanto existe Workspace.Cutscenes, así que no hay nada que insertar a mano en ReplicatedStorage. Si ya hiciste un RemoteEvent con ese nombre, bórralo: el LocalScript podría encontrar el tuyo, que nadie escucha en el servidor.

Los ajustes de arriba de CutsceneService
AjusteValor aquíQué cambia
INTRO_CUTSCENE"Intro"La carpeta de Workspace.Cutscenes que se reproduce cuando un jugador aparece por primera vez en un servidor. Ponlo en "" para no tener intro.
DEFAULT_MOVE_SECONDS3Cuánto tarda un deslizamiento cuando una toma no tiene el atributo MoveSeconds.
DEFAULT_HOLD_SECONDS1Cuánto se queda la cámara en una toma cuando no tiene el atributo HoldSeconds.
MAX_SHOTS30El número de toma más alto que CutsceneService busca en una cinemática.

Lo que hace el resto del script, en orden:

  • Lee las tomas en el servidor. readShots junta en una lista el CFrame y los atributos de cada parte numerada. El dispositivo del jugador recibe esa lista, así que nunca necesita las partes.
  • Una cinemática a la vez. play no hace nada mientras el jugador ya está viendo una, o cuando su personaje no tiene Humanoid o está muerto.
  • Un id para cada cinemática. El dispositivo devuelve el id cuando la cinemática termina o se salta, y solo el id que coincide libera al jugador, así que un mensaje atrasado de una cinemática anterior no puede terminar una más nueva.
  • Deja quieto al jugador anclando su HumanoidRootPart, y ancla también al nuevo personaje si el jugador reaparece a mitad de la cinemática. La referencia de Roblox dice que una parte anclada nunca cambia de posición por la gravedad, las colisiones ni ninguna otra física. WalkSpeed no se toca, así que esto no choca con un script de correr ni con un pase de velocidad. Al final desancla la root part aunque otro script la haya anclado, así que no ancles personajes en otro lado mientras pueda reproducirse una cinemática.
  • Una red de seguridad. task.delay libera al jugador después de la duración total de la cinemática más 2 segundos, aunque su dispositivo nunca responda.
  • Reproduce cada cinemática una vez por servidor. La tabla seen recuerda, para cada jugador, qué cinemáticas ya empezaron, así que la intro no se repite al reaparecer y una cinemática de trigger se reproduce una vez. playOnce devuelve true solo cuando la cinemática de verdad empezó.
  • Prepara a cada jugador. El bucle sobre Players:GetPlayers() del final atrapa a quien haya entrado mientras el script esperaba la carpeta Cutscenes.

Las tomas viajan al jugador en una sola llamada a FireClient, como una lista de tablas pequeñas. La página de remote events de Roblox dice que no envíes una tabla que mezcle claves numéricas y claves de texto; esta lista solo tiene claves numéricas, y cada toma dentro de ella solo tiene claves de texto, que es la forma que pide.

Paso 3: Añade el LocalScript que la reproduce

  1. En el Explorer, despliega StarterPlayer, pasa el cursor sobre StarterPlayerScripts e inserta un LocalScript llamado CutscenePlayer.
  2. Reemplaza su contenido con el código de abajo.
LocalScript en StarterPlayerScripts llamado CutscenePlayer
-- LocalScript en StarterPlayer > StarterPlayerScripts llamado CutscenePlayer.
-- Reproduce una cinemática que envía el servidor: barras negras, subtítulos, un botón Skip y la
-- cámara deslizándose de toma en toma. Después devuelve la cámara al jugador.

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 negra, como fracción de la altura de la pantalla
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- studs delante de la cámara que Roblox debe renderizar con más detalle
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 }

-- La pantalla de la cinemática: dos barras negras y un subtítulo, de borde a borde. Roblox dice
-- que ScreenInsets None es solo para lo que nadie pulsa, así que Skip tiene su propio ScreenGui abajo.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- cubrir toda la pantalla
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

-- El botón Skip mantiene los márgenes por defecto, así no queda bajo el notch de la cámara
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) -- en la barra de abajo, a la derecha
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 debe ser lo bastante grande para tocarlo en la pantalla de un celular pequeño
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

-- El movimiento actual: de un CFrame de cámara al siguiente en cierta cantidad de segundos
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Se ejecuta cada frame durante una cinemática. El Focus de una cámara Scriptable no sigue
-- nada por sí solo, así que también se pone aquí.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- algo la cambió, como un 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
		-- Ya se está reproduciendo una, así que deja que el servidor libere al jugador de esta ahora
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Oculta la lista de jugadores, la mochila y la barra de vida, recordando qué se mostraba
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- En celulares, oculta el joystick y el botón de salto, que están en las esquinas de abajo
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- Un mando solo puede pulsar un botón seleccionado, así que selecciona Skip para jugadores con mando
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Un paso después de la actualización de cámara de Roblox, como hace su tutorial de cámara
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- empieza cada movimiento desde donde esté la cámara ahora
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- Devuelve la cámara al personaje del jugador
	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 = ""
	-- Vuelve a activar solo los que esta cinemática desactivó, y deja el 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) -- permite que el servidor libere al jugador ahora
	busy = false
end

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

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

Un LocalScript en StarterPlayerScripts se copia al jugador una vez, cuando entra, y sigue ejecutándose cuando su personaje reaparece. Por eso los dos ScreenGuis tienen ResetOnSpawn desactivado: si estuviera activado, Roblox los borraría en el primer respawn, y este script no los volvería a crear. Los mensajes remotos que llegan antes de que el script se conecte a OnClientEvent se guardan en cola y se entregan cuando se conecta, así que un jugador que aparece rápido igual ve la intro.

Qué hace cada parte de CutscenePlayer
ParteQué hace
El ScreenGui CutsceneDos barras negras, cada una del 12% de la altura de la pantalla (BAR_HEIGHT), con el subtítulo en la barra de abajo. ScreenInsets None deja que las barras lleguen hasta los bordes mismos de la pantalla, y DisplayOrder 10 las dibuja por encima de los ScreenGuis con un DisplayOrder menor.
El ScreenGui CutsceneControlsSolo tiene el botón Skip, a la derecha de la barra de abajo, con un UISizeConstraint que lo mantiene en al menos 64 por 32 píxeles para que siga siendo fácil de tocar en un celular. Mantiene el ScreenInsets por defecto, que deja su contenido lejos de los botones de la barra superior de Roblox y de los notch de cámara. Roblox dice que uses None solo para contenido sin nada que pulsar, así que Skip no puede compartir el ScreenGui de las barras.
HIDDEN_CORE_GUISOculta la lista de jugadores, la mochila y la barra de vida con SetCoreGuiEnabled, después de anotar cuáles estaban activadas con GetCoreGuiEnabled, y al final vuelve a activar solo las que desactivó. Un juego que oculta la mochila en otro lado la sigue teniendo oculta, y un script que las activa durante la cinemática, como un menú principal, no se toca.
TouchControlsEnabledEn celulares y tablets, play pone GuiService.TouchControlsEnabled en false durante la cinemática. Eso oculta el joystick y el botón de salto, que están en las esquinas de abajo donde está Skip, y vuelven al final si estaban activados.
updateCameraSe ejecuta cada frame mientras se reproduce una cinemática. Calcula cuánto lleva del movimiento actual, le aplica easing con TweenService:GetValue, coloca la cámara entre las dos tomas con CFrame:Lerp y pone Focus 30 studs delante de la cámara.
waitOrSkipEspera el tiempo de movimiento y de pausa de una toma, comprobando la señal de Skip cada frame.
playPone la cámara en Scriptable, recorre las tomas en orden, después devuelve la cámara (CameraType Custom, CameraSubject el Humanoid), vuelve a activar las core GUIs y los controles táctiles y dispara el id de la cinemática al servidor. Si llega una segunda cinemática mientras otra se sigue reproduciendo, devuelve ese id de inmediato, para que el servidor no deje quieto al jugador por una cinemática que este dispositivo no mostró.
El botón SkipActivated se dispara con un clic del mouse, un toque o el botón A de un mando cuando el botón está seleccionado. Para un jugador cuya entrada preferida es un mando, play selecciona Skip cuando empieza la cinemática y quita la selección al final.

Cambia BAR_HEIGHT para hacer las barras más finas o más gruesas, y EASING_STYLE para cambiar cómo se sienten los movimientos (consulta Lo que el código de cámara hace bien). El subtítulo y el botón Skip usan TextScaled, así que su texto crece y se achica con la pantalla.

Paso 4: Reproduce una cinemática cuando un jugador toca una parte

La intro se reproduce sola. Para una cinemática en un lugar de tu mapa, como la primera vez que un jugador llega a un puente, añade una segunda cinemática y una parte trigger.

  1. En Workspace, Cutscenes, inserta un Folder llamado Bridge y coloca sus tomas como en el Paso 1, llamadas 1 y 2. En la línea de la Command Bar, usa Bridge en vez de Intro.
  2. Pasa el cursor sobre Workspace e inserta un Folder llamado CutsceneTriggers.
  3. Inserta dentro una Part llamada BridgeTrigger. Hazla lo bastante grande para que los jugadores no puedan pasar sin tocarla, por ejemplo una losa alta y ancha que cruce el camino. Marca Anchored, desmarca CanCollide y CanQuery, deja CanTouch marcado y pon Transparency en 1. Con CanQuery desactivado, la losa invisible no bloquea raycasts, como los disparos de la guía de armas (en inglés). Los eventos de toque dependen de CanTouch, no de CanQuery, así que el trigger sigue funcionando.
  4. Añádele un atributo llamado Cutscene, de tipo string, y pon su valor en Bridge: el nombre de la carpeta que se reproduce.

CutsceneService conecta Touched en cada parte que está directamente dentro de CutsceneTriggers cuando arranca el servidor, así que añade los triggers en Studio, no desde un script mientras el juego corre. Un trigger con CanTouch desactivado se salta con un aviso en Output, porque Roblox da un error cuando un script conecta Touched en una parte así.

Touched se dispara muchas veces seguidas mientras un personaje atraviesa una parte. La tabla seen y la regla de una cinemática a la vez convierten eso en una cinemática por jugador por servidor. Un jugador que toca el trigger mientras otra cinemática se está reproduciendo se ignora, y el trigger sigue listo para él.

Mantén los triggers fuera de las carreteras. El HumanoidRootPart de un jugador sentado está unido al asiento con un weld, y cuando una parte de un grupo con weld se ancla, Roblox ancla el resto con ella. Por eso un jugador que entra manejando a un trigger deja quieto todo su vehículo, pasajeros incluidos, hasta que termina la cinemática.

Lo que el código de cámara hace bien

Scriptable, y después de vuelta a Custom

Los scripts de cámara de Roblox no mueven ni actualizan la cámara mientras CameraType es Scriptable, y eso es lo que permite que CutscenePlayer la coloque. Al final vuelve a poner CameraType en Custom y hace que el Humanoid del jugador sea el CameraSubject, que es lo que siguen por defecto los scripts de cámara de Roblox. Eso también se ejecuta después de un Skip, así que el jugador nunca se queda mirando la última toma.

Dos pequeñas protecciones mantienen a la cinemática al mando mientras se reproduce. Si algo pone CameraType en otro valor a mitad de la cinemática, la función de cada frame lo vuelve a poner en Scriptable en el siguiente frame. Y el script vuelve a leer workspace.CurrentCamera al empezar cada cinemática, porque Roblox crea una Camera nueva si la actual llega a destruirse.

Focus, cada frame

Camera.Focus le dice al motor qué zona priorizar para trabajo como la iluminación. Los scripts de cámara de Roblox lo mantienen en el CameraSubject, pero no mientras la cámara es Scriptable, y la referencia de Roblox dice que en ese caso lo actualices cada frame: la iluminación dinámica de objetos como PointLights puede no renderizarse lejos del foco. CutscenePlayer lo pone 30 studs delante de la cámara (FOCUS_DISTANCE). Súbelo si tus tomas miran algo más lejos.

La función corre con RunService:BindToRenderStep, cada frame antes de dibujarlo, un paso de prioridad después de la actualización de cámara de Roblox (Enum.RenderPriority.Camera.Value + 1). Esa es la prioridad que usa el tutorial de cámara de Roblox, así que la cinemática coloca la cámara después de que se ejecuta el código de cámara de Roblox.

Easing con TweenService:GetValue

Un tween sobre camera.CFrame movería la cámara, pero igual hay que poner el Focus cada frame, así que CutscenePlayer hace el movimiento él mismo en la misma función. Para cada movimiento calcula qué parte del tiempo del movimiento ya pasó (de 0 a 1), la pasa por TweenService:GetValue con un estilo y una dirección de easing, y coloca la cámara a esa distancia entre las dos tomas con CFrame:Lerp, que mueve la posición en línea recta y gira la rotación de forma suave. GetValue limita su entrada entre 0 y 1, así que la cámara se detiene justo en la toma cuando se acaba el tiempo del movimiento.

Estilos de easing que van bien con un movimiento de cámara
EASING_STYLECómo se siente el movimiento
Enum.EasingStyle.Sine (el que se usa aquí)La velocidad sigue una onda senoidal, para un arranque y una parada suaves.
Enum.EasingStyle.QuadComo Sine, con una curva un poco más marcada.
Enum.EasingStyle.LinearVelocidad constante, así que cada movimiento arranca y para a toda velocidad.

La dirección es InOut: el easing se aplica hacia adelante en la primera mitad del movimiento y al revés en la segunda, así que la cámara acelera al salir de una toma y frena al llegar a la siguiente.

Streaming

Los places nuevos tienen instance streaming activado: por defecto el dispositivo de un jugador tiene la zona alrededor de su personaje, así que una toma que mira al otro lado del mapa puede mostrar un mundo vacío. CutsceneService le pide a Roblox que cargue para ese jugador la zona de cada toma con Player:RequestStreamAroundAsync: la zona de la primera toma antes de disparar el evento, esperando hasta 2 segundos, y la de cada toma siguiente 2 segundos antes de que la cámara empiece a moverse hacia ella.

Roblox dice que esto hace probable, no seguro, que la zona esté cargada, y que el efecto es temporal. Mantén las tomas importantes dentro de tu radio de streaming, o usa Player:AddReplicationFocus en el servidor para una zona que deba seguir cargada hasta que quites el foco. Con streaming desactivado, el dispositivo tiene todo el mapa de todos modos, y el pcall alrededor de cada petición hace que una petición que falla no pueda detener la cinemática.

En qué se equivocan los tutoriales viejos de cinemáticas

Si estás comparando esta guía con un video o una publicación de un foro, estas son las diferencias que importan, con la razón por la que cada patrón es un problema.

Patrones comunes en tutoriales de cinemáticas, y lo que hace esta guía en su lugar
El tutorialEl problemaEsta guía
Mueve la cámara con camera:Interpolate()Roblox marca Interpolate como obsoleto y dice que animes la cámara con TweenService.Aplica easing a cada movimiento con TweenService:GetValue y coloca la cámara cada frame.
Hace tween de camera.CFrame y nada másFocus se queda donde lo dejaron los scripts de cámara, cerca del personaje, así que la iluminación dinámica lejos de ahí puede no renderizarse (referencia de Camera.Focus de Roblox).Pone Focus cada frame en el render step.
Nunca devuelve la cámaraEl jugador se queda atascado mirando la última toma.Pone CameraType en Custom y CameraSubject en el Humanoid al final, también después de un Skip.
Empieza la cinemática desde Touched en un LocalScriptNada impide que se repita en cada toque, y la decisión está en un dispositivo que controla el jugador.El servidor elige al jugador y recuerda quién ya la vio.
Lee las partes de la cámara en el clienteCon streaming activado, las partes lejos del personaje pueden no existir todavía en el dispositivo.El servidor lee las partes, envía sus CFrames y pide la zona de cada toma poco antes de que llegue la cámara.

Qué puede y qué no puede cambiar un jugador

Da por hecho que un tramposo controla todo en su propio dispositivo: puede editar o borrar CutscenePlayer y disparar CutsceneEvent con cualquier valor. En una cinemática eso importa muy poco, siempre que nada real dependa de ella.

Lo que puede intentar un tramposo, y lo que pasa
Un tramposo intentaResultado
Saltarse una cinemática, o no reproducirla nuncaPermitido: es su propia pantalla. Nunca des una recompensa por "terminar la cinemática".
Disparar CutsceneEvent con cualquier valorSolo hace algo un número que coincida con su propia cinemática actual, y lo único que hace es liberarlo antes.
Tocar un trigger desde cualquier parte del mapaEs posible: cada dispositivo controla su propio personaje, y la documentación de seguridad de Roblox incluye manipular eventos Touched entre lo que puede hacer. Ve esa cinemática una vez, y no pasa nada más.
Moverse de todos modos durante una cinemáticaNo gana nada. El congelamiento evita que los jugadores honestos se vayan a mitad de la cinemática; no es una comprobación de seguridad.
Usar el remote para empezar una cinemática a otra personaNo es posible. Solo el servidor dispara CutsceneEvent a un jugador, y el único mensaje que un dispositivo puede devolver es "esta cinemática terminó".

Si una cinemática lleva a algo real, como una puerta que se abre después o un jefe que aparece, haz que el servidor lo haga con su propio temporizador, no cuando el dispositivo dice que la cinemática terminó.

Paso 5: Pruébala

  1. Coloca las tres tomas de Intro con la línea de la Command Bar. Dale a la toma 1 el Caption "Welcome to the village", dale a la toma 2 MoveSeconds 2.5 y el Caption "Find the bridge", y deja la toma 3 sin atributos.
  2. Pulsa Play (F5). Aparecen las barras negras y la cámara corta a la toma 1 con su subtítulo, se desliza a la toma 2 en 2.5 segundos y luego a la toma 3 en 3 segundos sin subtítulo. Después la cámara vuelve detrás de tu personaje y regresa la lista de jugadores. No puedes caminar mientras se reproduce.
  3. Detén, pulsa Play otra vez y pulsa Skip mientras la cámara se desliza a la toma 2. La cámara vuelve al instante y puedes caminar enseguida.
  4. Camina hacia BridgeTrigger: se reproduce la cinemática Bridge. Atraviésalo otra vez: no pasa nada.
  5. Elige Server & Clients en el menú desplegable del modo de prueba, pon 2 clientes y pulsa Play. Cuando Client 1 entra al trigger, la cinemática Bridge se reproduce solo en Client 1, y Client 2 puede seguir caminando.
  6. Deja Workspace.StreamingEnabled activado y mueve una toma lejos del spawn. El escenario debería estar ahí cuando llega la cámara (es probable, no seguro: consulta Streaming).
  7. Para un mando, detén, pulsa Play, abre el Controller Emulator (pestaña Emulation y luego Controller) y entra a BridgeTrigger con el mando emulado: Skip debería estar seleccionado, así que A la salta. Si usas el Device Simulator de Studio (era una beta cuando lo comprobamos el 15 de octubre de 2026: actívalo en File, Beta Features, New Device Simulator, y reinicia Studio), elige un celular, ponlo en horizontal y comprueba que Skip queda lejos del notch de la cámara y es fácil de tocar, y que el joystick y el botón de salto están ocultos mientras se reproduce la cinemática.
  8. Si también hiciste el menú principal, pulsa Play, luego el botón Play del menú, y deja que la intro llegue al final: la lista de jugadores debería volver a la pantalla después.

Mantén abierta la ventana Output (menú Window y luego Output) todo el tiempo. Estos scripts no imprimen nada cuando funcionan, así que cualquier aviso o error rojo de CutsceneService o CutscenePlayer es un problema real. Consulta Errores comunes.

Cómo ampliarla

Mostrar la intro solo en la primera visita de un jugador

La tabla seen dura un servidor, así que un jugador que vuelve a entrar ve la intro otra vez. Para mostrarla solo en su primera visita, guarda una marca como SeenIntro con el resto de sus datos, usando el módulo PlayerData del tutorial de DataStore. Deja INTRO_CUTSCENE como está y cambia la parte de la intro de onCharacterAdded en CutsceneService: espera hasta que PlayerData.Get(player) devuelva los datos del jugador, sáltate la intro cuando data.SeenIntro sea true, y pon data.SeenIntro = true solo cuando playOnce(player, INTRO_CUTSCENE) devuelva true. No empieces la intro desde el código que carga los datos: los datos pueden terminar de cargar antes de que aparezca el personaje, y play no hace nada sin personaje, así que la marca se guardaría por una intro que nadie vio.

Personajes que actúan en la cinemática

Haz la animación en el Animation Editor de Studio, o en un plugin de animación de terceros como Moon Animator, que la propia documentación de Roblox menciona, y reprodúcela en un rig de NPC de la toma cuando llegue la cámara. La referencia de Animator de Roblox dice que las animaciones de un NPC solo se replican cuando el servidor las carga y las empieza, así que reprodúcela desde un Script del servidor si todos los jugadores deben ver actuar al NPC. Si la cargas y la empiezas en CutscenePlayer, la animación no se replica, lo que va bien para una cinemática que solo ve un jugador. La guía de scripts de animación muestra cómo reproducir una en un NPC desde un Script del servidor.

Diálogo

Los subtítulos van bien para frases cortas que se reproducen solas. Para una conversación en la que el jugador responde y elige opciones, consulta la guía de diálogo con NPC.

Una intro después del menú principal

La guía del menú principal desactiva CharacterAutoLoads, así que nadie aparece hasta que pulsa Play. CutsceneService reproduce la intro en la primera aparición del jugador, así que con los dos sistemas la intro se reproduce en la primera aparición después de Play. El menú vuelve a activar las core GUIs cuando aparece el personaje, lo que puede pasar mientras la intro ya se está reproduciendo, así que la lista de jugadores puede verse durante la intro. CutscenePlayer solo vuelve a activar las que ocultó él mismo, así que no toca el cambio del menú y siguen activadas después de la intro. El truco de la Command Bar de la guía del menú principal para apuntar una parte de cámara es el mismo que usa el Paso 1.

Un vuelo por el mapa al empezar una ronda

Para empezar una cinemática desde otro script del servidor, como un vuelo por el mapa cuando empieza una ronda del sistema de rondas, añade un BindableEvent llamado PlayCutscene a ServerStorage. Al final de CutsceneService, conecta su Event a la función play, y haz que el script de rondas lo dispare con cada jugador y el nombre de la cinemática. play se salta la comprobación de una vez por servidor, así que el vuelo se reproduce en cada ronda.

Plugins de cinemáticas

Puedes usar plugins junto con esta guía. Si un plugin de cinemáticas escribe su propio script de cámara, comprueba que devuelva la cámara (CameraType Custom y un CameraSubject) y que ponga Focus mientras la cámara es Scriptable, y deja la decisión de quién ve la cinemática en el servidor, como en esta guía.

Errores comunes y soluciones

Abre la ventana Output (menú Window y luego Output) antes de pulsar Play. La mayoría de los problemas con cinemáticas imprimen un aviso ahí o vienen de un nombre que no coincide.

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

CutsceneService está esperando una carpeta llamada Cutscenes directamente en Workspace. Créala como en el Paso 1 y revisa cómo está escrita y la C mayúscula. Hasta que exista, CutsceneService no crea CutsceneEvent, así que CutscenePlayer también espera.

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

CutscenePlayer está esperando el remote que crea CutsceneService. Comprueba que CutsceneService es un Script, no un LocalScript, directamente dentro de ServerScriptService, que no está desactivado, y que Output no muestra ningún error ni aviso de Cutscenes que venga de él.

CutsceneService: no folder named Intro in Workspace.Cutscenes

El nombre en INTRO_CUTSCENE, o en el atributo Cutscene de un trigger, no coincide con ninguna carpeta dentro de Workspace.Cutscenes. Los nombres distinguen mayúsculas y minúsculas.

No se reproduce nada, y Output no muestra nada

La carpeta no tiene ninguna parte llamada 1, o sus partes no están directamente dentro (por ejemplo, están dentro de un Model). CutsceneService lee en orden las partes llamadas 1, 2, 3 y se detiene en el primer número que falta. Recuerda también que cada cinemática se reproduce una vez por jugador por servidor: detén la prueba y pulsa Play otra vez.

La cámara apunta hacia el lado equivocado

La cámara mira hacia el mismo lado que la cara frontal de la parte de la toma. Mueve la cámara de Studio a la vista que quieres y vuelve a ejecutar la línea de la Command Bar del Paso 1 para esa toma.

El trigger no hace nada

Comprueba que la parte trigger está directamente dentro de Workspace.CutsceneTriggers cuando empieza el juego, que CanTouch está marcado (si no, Output muestra un aviso) y que su atributo Cutscene es un string con el nombre de una carpeta de Workspace.Cutscenes. Que no pase nada al atravesarlo por segunda vez es a propósito.

La cámara se queda en la última toma después de la cinemática

CutscenePlayer se detuvo por un error antes de poder devolver la cámara, así que busca un error rojo suyo en Output. Otro script que sigue poniendo CameraType en Scriptable, como una cámara de menú que sigue conectada, también puede quedarse con la cámara.

Constrúyela con RoCode

Si prefieres no montar esto a mano, RoCode puede construirlo en el place que tienes abierto. RoCode es un agente de IA independiente para Roblox Studio, no lo hace Roblox: describes la función en su chat web y su plugin de Studio crea la parte y los scripts en tu Explorer, así que no copias código de una ventana de chat.

Tú escribes

Añade una cinemática de intro: una carpeta Cutscenes con una carpeta Intro de tomas llamadas del 1 al 3, subtítulos desde un atributo Caption, barras negras y un botón Skip, que se reproduzca una vez cuando un jugador aparece por primera vez, con el servidor dejando quieto al jugador y la cámara devuelta al final.

RoCode hace
  • Puede revisar primero tu place con Search Scripts, por ejemplo para encontrar un script de menú o de cámara que ya pone CameraType, para que los dos no choquen
  • Crea las carpetas y la parte trigger con Create Instance, y pone atributos como Caption y MoveSeconds en las partes
  • Escribe CutsceneService y CutscenePlayer con Create Script
  • Tiene la instrucción de comprobar cada script que escribe con Check Script, que lo compila en Studio sin ejecutarlo, y pone un punto de deshacer antes y después de cada lote de cambios

Coloca tú las partes de las tomas moviendo la cámara de Studio a cada vista, y después pide los scripts. Con el plugin 3.9 o posterior RoCode puede hacer una prueba corta y leer los errores, y con el plugin 3.9.11 o posterior puede controlar un personaje de prueba para comprobar que el juego funciona, pero no toma capturas de pantalla mientras corre el juego, así que la cinemática la miras tú. Para el orden en que construir un juego entero, consulta cómo hacer un juego de Roblox con IA, sistema por sistema (en inglés). Cómo se conecta RoCode a Studio.

Preguntas frecuentes

¿Cómo hago que una cinemática se reproduzca cuando un jugador entra?

Llama Intro a una carpeta de tomas en Workspace.Cutscenes, o cambia INTRO_CUTSCENE al nombre de tu carpeta. CutsceneService la reproduce en la primera aparición de cada jugador en un servidor. Para mostrarla solo en la primera visita de alguien, guarda una marca en un data store y ponla solo cuando la intro haya empezado, como se explica en Cómo ampliarla.

¿Puedo hacer una cinemática sin plugins?

Sí. Esta guía usa solo partes, atributos y dos scripts, y la línea de la Command Bar coloca cada toma justo donde está la cámara de Studio. Los plugins como Moon Animator siguen siendo útiles para animar personajes que actúan en la cinemática.

¿Por qué no se mueve la cámara en mi cinemática?

Normalmente el código de la cámara está en un Script del servidor, pero solo un LocalScript puede mover la cámara de un jugador, porque cada dispositivo tiene la suya. La otra causa común es que CameraType no está en Scriptable, así que los scripts de cámara por defecto de Roblox siguen devolviendo la cámara al personaje.

¿Cómo hago que el jugador no se mueva durante una cinemática?

Ancla su HumanoidRootPart en el servidor mientras se reproduce y desánclalo después, como hace CutsceneService. Una parte anclada nunca se mueve por la física. No toca WalkSpeed, así que no choca con un script de correr ni con un pase de velocidad.

¿Cómo pongo un botón para saltar la cinemática?

Pon un TextButton en la pantalla de la cinemática y conecta su evento Activated, que se dispara con un clic, un toque o el botón A de un mando cuando el botón está seleccionado. El Skip de CutscenePlayer activa una señal que el bucle de tomas comprueba cada frame, se selecciona solo para jugadores con mando y está en su propio ScreenGui con los márgenes por defecto, para que el notch de la cámara de un celular no lo tape. El joystick y el botón de salto se ocultan mientras se reproduce la cinemática, así que no quedan al lado.

¿Por qué el mundo sale vacío en mi cinemática?

Con instance streaming activado, el dispositivo de un jugador solo tiene la zona cerca de su personaje. Haz que el servidor llame a player:RequestStreamAroundAsync para cada toma poco antes de que llegue la cámara, como hace CutsceneService. Roblox dice que esto hace probable, no seguro, que la zona esté cargada, así que mantén las tomas importantes dentro de tu radio de streaming, o usa Player:AddReplicationFocus para una zona que deba seguir cargada.

Fuentes y lecturas

Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 14 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.