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:Interpolateestá obsoleto. La referencia de Roblox dice que animes la cámara con TweenService.
En esta página
Cómo funciona una cinemática
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:
- El servidor decide que un jugador debe ver una cinemática: la
Introen su primera aparición en el servidor, u otra cuando toca una parte trigger. - 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
CutsceneEventsolo a ese jugador, con un id y la lista de tomas. - 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.
- Cuando termina la última toma, o el jugador pulsa Skip, devuelve la cámara al personaje y dispara
CutsceneEvental servidor con el mismo id. - 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.
| Pieza | Dónde va | Qué hace |
|---|---|---|
Script CutsceneService | ServerScriptService | Decide quién ve cada cinemática y cuándo, lee las tomas, deja quieto al jugador y recuerda quién vio qué. |
LocalScript CutscenePlayer | StarterPlayer, StarterPlayerScripts | Reproduce 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 CutsceneEvent | ReplicatedStorage (lo crea CutsceneService) | Lleva las tomas del servidor a un jugador, y de vuelta el mensaje de "la cinemática terminó". |
Folder Cutscenes | Workspace | Una carpeta por cinemática, como Intro, con las partes de las tomas llamadas 1, 2, 3. |
Folder CutsceneTriggers | Workspace (opcional) | Partes que empiezan una cinemática cuando un jugador las toca. |
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.
- En el Explorer, pasa el cursor sobre Workspace, haz clic en el botón + e inserta un Folder llamado
Cutscenes. Dentro, inserta un Folder llamadoIntro. Los nombres distinguen mayúsculas y minúsculas. - Mueve la cámara de Studio hasta la primera vista que quieres, como si encuadraras una foto.
- Inserta una Part en Intro y cámbiale el nombre a
1. - 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,CurrentCameraes 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. - 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.
- Repite con las siguientes vistas, llamando a las partes
2,3y 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.
| Atributo | Tipo | Por defecto | Qué hace |
|---|---|---|---|
MoveSeconds | number | 3 | Segundos 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. |
HoldSeconds | number | 1 | Segundos que la cámara se queda en esta toma después de llegar. |
Caption | string | ninguno | Texto 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.
-- 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.
| Ajuste | Valor 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_SECONDS | 3 | Cuánto tarda un deslizamiento cuando una toma no tiene el atributo MoveSeconds. |
DEFAULT_HOLD_SECONDS | 1 | Cuánto se queda la cámara en una toma cuando no tiene el atributo HoldSeconds. |
MAX_SHOTS | 30 | El 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.
readShotsjunta 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.
playno 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.delaylibera 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
seenrecuerda, 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.playOncedevuelve 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
- En el Explorer, despliega StarterPlayer, pasa el cursor sobre StarterPlayerScripts e inserta un LocalScript llamado
CutscenePlayer. - Reemplaza su contenido con el código de abajo.
-- 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.
| Parte | Qué hace |
|---|---|
El ScreenGui Cutscene | Dos 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 CutsceneControls | Solo 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_GUIS | Oculta 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. |
TouchControlsEnabled | En 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. |
updateCamera | Se 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. |
waitOrSkip | Espera el tiempo de movimiento y de pausa de una toma, comprobando la señal de Skip cada frame. |
play | Pone 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 Skip | Activated 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.
- En Workspace, Cutscenes, inserta un Folder llamado
Bridgey coloca sus tomas como en el Paso 1, llamadas1y2. En la línea de la Command Bar, usaBridgeen vez deIntro. - Pasa el cursor sobre Workspace e inserta un Folder llamado
CutsceneTriggers. - 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. - Añádele un atributo llamado
Cutscene, de tipo string, y pon su valor enBridge: 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.
| EASING_STYLE | Có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.Quad | Como Sine, con una curva un poco más marcada. |
Enum.EasingStyle.Linear | Velocidad 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.
| El tutorial | El problema | Esta 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ás | Focus 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ámara | El 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 LocalScript | Nada 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 cliente | Con 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.
| Un tramposo intenta | Resultado |
|---|---|
| Saltarse una cinemática, o no reproducirla nunca | Permitido: es su propia pantalla. Nunca des una recompensa por "terminar la cinemática". |
Disparar CutsceneEvent con cualquier valor | Solo 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 mapa | Es 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ática | No 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 persona | No 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
- 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 2MoveSeconds2.5 y elCaption"Find the bridge", y deja la toma 3 sin atributos. - 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.
- 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.
- Camina hacia BridgeTrigger: se reproduce la cinemática Bridge. Atraviésalo otra vez: no pasa nada.
- 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.
- Deja
Workspace.StreamingEnabledactivado y mueve una toma lejos del spawn. El escenario debería estar ahí cuando llega la cámara (es probable, no seguro: consulta Streaming). - 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.
- 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.
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.
- 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
- Roblox Creator Docs: Customize the camera (en inglés). la Camera propia de cada cliente, Scriptable, CFrame y Focus
- Roblox Engine API: Camera (en inglés). CameraType, CameraSubject, Focus cada frame, e Interpolate obsoleto
- Roblox Creator Docs: Control the user's camera (en inglés). BindToRenderStep un paso de prioridad después de la cámara
- Roblox Engine API: TweenService:GetValue (en inglés). alpha con easing, limitado entre 0 y 1
- Roblox Engine API: ScreenGui.ScreenInsets (en inglés). por qué None es solo para contenido sin nada que pulsar
- Roblox Creator Docs: Instance streaming (en inglés). activado por defecto en places nuevos, y el foco de replicación
- Roblox Creator Docs: Streaming techniques (en inglés). cargar una zona antes de disparar un evento
- Roblox Engine API: Player:RequestStreamAroundAsync (en inglés). una petición temporal sin garantía
- Roblox Creator Docs: Remote events and callbacks (en inglés). mensajes en cola y qué tablas se pueden enviar
- Roblox Creator Docs: Network ownership, movement validation, and physics (en inglés). qué puede hacer un cliente con su propio personaje, incluido manipular eventos Touched
- Roblox Engine API: Animator:LoadAnimation (en inglés). qué animaciones se replican
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.