Tutoriál · Herní systémy

Jak udělat cutscénu v Roblox Studiu

Cutscéna v Robloxu je kamera, která na několik sekund převezme řízení: přepíná nebo plynule letí mezi záběry, ukáže titulek a vrátí ovládání hráči. V tomto návodu postavíme cutscénu, kterou nastavíte rozmístěním neviditelných partů tam, kde má stát kamera, bez pluginů. Server rozhoduje, kdy ji hráč uvidí (při prvním spawnu nebo při dotyku spouštěče), a zařízení hráče hýbe kamerou, ukazuje černé pruhy a tlačítko Skip a kameru vrací.

Aktualizováno 20. listopadu 202620 min čteníAutor:

Ve zkratce

Rozmístěte neviditelné ukotvené party s názvy 1, 2, 3 ve složce uvnitř Workspace.Cutscenes, každý čelem tam, kam se má kamera dívat. Script v ServerScriptService přečte jejich CFrame, drží hráče na místě a pošle záběry tomuto hráči přes RemoteEvent. LocalScript ve StarterPlayerScripts nastaví workspace.CurrentCamera.CameraType na Scriptable, každý snímek posouvá kameru od záběru k záběru (s vyhlazením přes TweenService:GetValue) a pak vrátí CameraType na Custom a CameraSubject na Humanoid hráče.

  • Kameru může ovládat jen zařízení hráče, proto je kód kamery LocalScript. Server jen rozhoduje, kdo vidí kterou cutscénu a kdy.
  • Když je kamera Scriptable, Roblox přestane aktualizovat Camera.Focus. Referenční příručka říká aktualizovat Focus každý snímek, jinak se dynamické osvětlení daleko od starého fokusu nemusí vykreslit.
  • Camera:Interpolate je zastaralý. Referenční příručka Robloxu říká animovat kameru přes TweenService.
Na této stránce
  1. Jak to funguje
  2. 1. Záběry
  3. 2. Serverový skript
  4. 3. LocalScript
  5. 4. Spouštěč
  6. Detaily kamery
  7. Starší tutoriály
  8. Ochrana proti podvodům
  9. 5. Test
  10. Rozšíření
  11. Common errors
  12. S RoCode
  13. Časté otázky
  14. Zdroje a další čtení

Jak cutscéna funguje

IlustraceIntro ze dvou záběrů ve skutečné rychlosti: přepnutí na první záběr, pauza 1 sekunda, průlet k mostu za 2.5 sekundy, pauza 1 sekunda, pak se kamera vrátí k hráči.

Každé zařízení hráče má vlastní objekt Camera v workspace.CurrentCamera, takže tím, co hráč vidí, může hýbat jen LocalScript. Rozhodovat, kdo vidí kterou cutscénu a kdy, je práce serveru. Návod dělí práci právě takto. Jedna cutscéna proběhne takto:

  1. Server rozhodne, že hráč má cutscénu vidět: Intro při prvním spawnu na serveru nebo jinou, když se dotkne spouštěcího partu.
  2. CutsceneService přečte CFrame a nastavení partů záběrů, požádá Roblox, aby tomuto hráči načetl oblast prvního záběru, ukotví HumanoidRootPart hráče, aby stál na místě, a pošle CutsceneEvent jen tomuto hráči s id a seznamem záběrů.
  3. CutscenePlayer na zařízení hráče ukáže černé pruhy a tlačítko Skip, schová seznam hráčů, batoh, ukazatel zdraví a dotykové ovládání, udělá kameru Scriptable a každý snímek s ní hýbe.
  4. Když poslední záběr skončí nebo hráč klikne na Skip, vrátí kameru postavě a pošle serveru CutsceneEvent se stejným id.
  5. Server hráče odkotví. Pokud tato zpráva nikdy nepřišla, odkotví ho stejně, až uplyne délka cutscény plus 2 sekundy. Časovač se spustí, když server cutscénu odešle, a při pomalém vstupu může zařízení začít intro o několik sekund později, protože LocalScript mimo ReplicatedFirst se nespustí, dokud se hra nenačte. Hráč se pak může znovu hýbat dřív, než intro na jeho obrazovce skončí.
Z čeho se systém cutscén skládá
PrvekKde jeCo dělá
Script CutsceneServiceServerScriptServiceRozhoduje, kdo vidí kterou cutscénu a kdy, čte záběry, drží hráče na místě a pamatuje si, kdo co už viděl.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsPřehrává cutscénu na obrazovce hráče: pruhy, titulky, Skip a pohyb kamery. Na konci kameru vrátí.
RemoteEvent CutsceneEventReplicatedStorage (vytváří ho CutsceneService)Nese záběry ze serveru jednomu hráči a zpět zprávu „cutscéna skončila“.
Folder CutscenesWorkspaceJedna složka na cutscénu, například Intro, s party záběrů 1, 2, 3.
Folder CutsceneTriggersWorkspace (volitelné)Party, které spustí cutscénu, když se jich hráč dotkne.
Explorer, když je systém cutscén hotový. Složky Bridge a CutsceneTriggers přibudou v kroku 4. Když se hra spustí, CutsceneService přidá do ReplicatedStorage RemoteEvent s názvem CutsceneEvent.
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

Krok 1: Rozmístěte záběry kamery

Každý záběr je neviditelný part. Kamera převezme pozici partu a dívá se stejným směrem jako jeho přední stěna, takže umístit záběr znamená umístit kameru.

  1. V Exploreru najeďte myší na Workspace, klikněte na tlačítko + a vložte Folder s názvem Cutscenes. Do ní vložte Folder s názvem Intro. Na velikosti písmen v názvech záleží.
  2. Natočte kameru Studia na první požadovaný pohled, jako byste skládali záběr na fotku.
  3. Vložte Part do Intro a přejmenujte ho na 1.
  4. Otevřete Command Bar (na kartě Script nebo přes Window, pak Script) a spusťte workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. V režimu úprav je CurrentCamera pohled, kterým se díváte, takže part se postaví přesně do tohoto záběru. Hranaté závorky a uvozovky jsou potřeba, protože název začínající číslicí se nedá psát za tečku.
  5. V Properties partu zaškrtněte Anchored, odškrtněte CanCollide, CanTouch a CanQuery a nastavte Transparency na 1. Anchored mu nedovolí propadnout mapou; zbytek zajistí, že nebude překážet hráčům, spouštět události dotyku ani blokovat raycasty.
  6. Zopakujte pro další pohledy, party pojmenujte 2, 3 a tak dále a v řádku pro Command Bar měňte číslo. CutsceneService přehrává záběry podle pořadí čísel a zastaví se na prvním chybějícím čísle, takže díra v číslování cutscénu předčasně utne.

Chcete-li záběr později změnit, natočte kameru na nový pohled a spusťte stejný řádek s číslem tohoto záběru. S Transparency 1 jsou party neviditelné i ve Studiu, proto je vybírejte v Exploreru, když je potřebujete.

Každý záběr může mít ještě tři volitelné atributy. Chcete-li přidat atribut, vyberte part, posuňte okno Properties na část Attributes, klikněte na +, zadejte název, vyberte typ a klikněte na Save.

Volitelné atributy na každém partu záběru
AtributTypVýchozíCo dělá
MoveSecondsnumber3Kolik sekund kamera letí od předchozího záběru k tomuto. 0 udělá ostré přepnutí. Záběr 1 je vždy přepnutí, takže u něj atribut nic nedělá.
HoldSecondsnumber1Kolik sekund kamera na tomto záběru po příletu stojí.
CaptionstringžádnýText na spodním pruhu od okamžiku, kdy kamera začne letět k tomuto záběru. Záběr bez Caption text vymaže.

Číslo menší než 0 nebo větší než 60 a také atribut špatného typu se nahradí výchozí hodnotou.

Krok 2: Přidejte serverový skript

Najeďte myší na ServerScriptService, vložte Script s názvem CutsceneService a vložte do něj kód níže. Nastavení nahoře jsou řádky, které můžete měnit.

Script v ServerScriptService s názvem CutsceneService
-- Script v ServerScriptService s názvem CutsceneService.
-- Rozhoduje, kdo vidí kterou cutscénu a kdy. Čte záběry kamery z očíslovaných
-- partů ve Workspace.Cutscenes, drží hráče na místě a říká zařízení
-- tohoto hráče, ať záběry přehraje. Samotnou kamerou lze hýbat jen na zařízení.

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

-- Nastavení
local INTRO_CUTSCENE = "Intro" -- hraje jednou při prvním spawnu hráče; "" pro vypnutí
local DEFAULT_MOVE_SECONDS = 3 -- doba průletu k záběru, pokud nemá MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- doba na záběru, pokud nemá HoldSeconds
local MAX_SHOTS = 30

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

-- Tento skript si CutsceneEvent vytvoří sám, proto ho nepřidávejte ručně
local cutsceneEvent = Instance.new("RemoteEvent")
cutsceneEvent.Name = "CutsceneEvent"
cutsceneEvent.Parent = ReplicatedStorage

type Shot = { cframe: CFrame, move: number, hold: number, caption: string }

local seen: { [Player]: { [string]: boolean } } = {}
local playing: { [Player]: number } = {} -- id cutscény, kterou hráč sleduje
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

-- Záběry jsou party 1, 2, 3 ... ve složce s názvem cutscény
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,
			-- první záběr je přepnutí, takže kamera do něj hned skočí
			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 -- tato cutscéna už skončila
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- jedna cutscéna najednou
	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

	-- Se zapnutým instance streaming nemusí mít zařízení hráče oblast,
	-- na kterou se záběr dívá, a požadavek oblast načte jen dočasně. Načteme
	-- oblast prvního záběru teď (čekáme až 2 sekundy) a oblast každého dalšího
	-- 2 sekundy předtím, než k němu kamera poletí.
	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 -- hráč odešel, zatímco se oblast načítala
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- sekund od teď do začátku průletu k tomuto záběru
	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
	-- Pojistka: hráče rozmrazíme, i když jeho zařízení nikdy neodpovědělo
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Vrací true, jen pokud se cutscéna pro tohoto hráče spustila
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

-- Zařízení hráče hlásí, že cutscéna skončila nebo byla přeskočena
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Spouštěcí party: dotyk spustí cutscénu z jejich atributu Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Připojení Touched k partu s vypnutým CanTouch hodí chybu, proto jen varujeme
			warn(`CutsceneService: tick CanTouch on {trigger:GetFullName()} so it can start a cutscene`)
			continue
		end
		trigger.Touched:Connect(function(otherPart: BasePart)
			local name = trigger:GetAttribute("Cutscene")
			local character = otherPart:FindFirstAncestorOfClass("Model")
			local player = character and Players:GetPlayerFromCharacter(character)
			if player and typeof(name) == "string" then
				playOnce(player, name)
			end
		end)
	end
end

local function onCharacterAdded(player: Player, character: Model)
	character:WaitForChild("HumanoidRootPart", 10)
	if playing[player] then
		setFrozen(player, true) -- respawn během cutscény, držíme na místě i novou postavu
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- už nastaveno
	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 -- všichni, kdo přišli, zatímco skript čekal na Cutscenes
	onPlayerAdded(player)
end

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

CutsceneService si RemoteEvent CutsceneEvent vytvoří sám, jakmile se objeví Workspace.Cutscenes, takže do ReplicatedStorage nic vkládat ručně nemusíte. Pokud jste už RemoteEvent s tímto názvem vytvořili, smažte ho: LocalScript by mohl najít ten váš, a ten na serveru nikdo neposlouchá.

Nastavení nahoře v CutsceneService
NastaveníHodnota tadyCo mění
INTRO_CUTSCENE"Intro"Složka ve Workspace.Cutscenes, která hraje při prvním spawnu hráče na serveru. Nastavte "", pokud intro nechcete.
DEFAULT_MOVE_SECONDS3Jak dlouho trvá průlet, pokud záběr nemá atribut MoveSeconds.
DEFAULT_HOLD_SECONDS1Jak dlouho kamera na záběru stojí, pokud nemá atribut HoldSeconds.
MAX_SHOTS30Nejvyšší číslo záběru, které CutsceneService v jedné cutscéně hledá.

Co dělá zbytek skriptu, popořadě:

  • Čte záběry na serveru. readShots sesbírá CFrame a atributy každého očíslovaného partu do seznamu. Zařízení hráče dostane tento seznam, takže samotné party nepotřebuje.
  • Jedna cutscéna najednou. play nic neudělá, dokud hráč už nějakou cutscénu sleduje, nebo pokud jeho postava nemá Humanoid či je mrtvá.
  • Každá cutscéna má vlastní id. Zařízení pošle id zpět, když cutscéna skončí nebo je přeskočena, a hráče rozmrazí jen odpovídající id, takže opožděná zpráva z minulé cutscény nemůže ukončit novou.
  • Drží hráče na místě ukotvením jeho HumanoidRootPart a ukotví i novou postavu, pokud se hráč uprostřed cutscény respawnuje. Referenční příručka Robloxu uvádí, že ukotvený part nikdy nezmění pozici kvůli gravitaci, kolizím ani jiné fyzice. WalkSpeed se nemění, takže to není v konfliktu se skriptem sprintu ani passem na rychlost. Na konci skript odkotví root part, i když ho ukotvil jiný skript, proto neukotvujte postavy jinde, dokud může běžet cutscéna.
  • Pojistka. task.delay hráče rozmrazí po celé délce cutscény plus 2 sekundy, i když jeho zařízení nikdy neodpovědělo.
  • Každá cutscéna jednou za server. Tabulka seen si pro každého hráče pamatuje, které cutscény už začaly, takže intro se při respawnu neopakuje a cutscéna ze spouštěče hraje jednou. playOnce vrací true, jen pokud se cutscéna opravdu spustila.
  • Nastaví každého hráče. Smyčka přes Players:GetPlayers() na konci zachytí všechny, kdo přišli, zatímco skript čekal na složku Cutscenes.

Záběry jdou hráči jedním voláním FireClient jako seznam malých tabulek. Stránka Robloxu o remote events říká neposílat tabulku, kde jsou smíchané číselné a textové klíče; tento seznam má jen číselné klíče a každý záběr uvnitř jen textové, což je podoba, kterou tam doporučují.

Krok 3: Přidejte LocalScript, který ji přehraje

  1. V Exploreru rozbalte StarterPlayer, najeďte myší na StarterPlayerScripts a vložte LocalScript s názvem CutscenePlayer.
  2. Nahraďte jeho obsah kódem níže.
LocalScript v StarterPlayerScripts s názvem CutscenePlayer
-- LocalScript ve StarterPlayer > StarterPlayerScripts s názvem CutscenePlayer.
-- Přehraje cutscénu, kterou pošle server: černé pruhy, titulky, tlačítko Skip a
-- kameru, která letí od záběru k záběru. Pak vrátí kameru hráči.

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 -- každý černý pruh jako podíl výšky obrazovky
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- kolik studů před kamerou má Roblox vykreslovat nejpodrobněji
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 }

-- Obrazovka cutscény: dva černé pruhy a titulek, od okraje k okraji. Roblox radí dávat
-- ScreenInsets None jen tomu, na co nikdo neklepe, proto má Skip níže vlastní ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- na celou obrazovku
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

-- Tlačítko Skip má výchozí odsazení, takže ho výřez kamery nezakryje
local controls = Instance.new("ScreenGui")
controls.Name = "CutsceneControls"
controls.ResetOnSpawn = false
controls.DisplayOrder = 11
controls.Enabled = false

local skipButton = Instance.new("TextButton")
skipButton.AnchorPoint = Vector2.new(1, 0.5)
skipButton.Size = UDim2.fromScale(0.1, BAR_HEIGHT * 0.5)
skipButton.Position = UDim2.new(1, -16, 1 - BAR_HEIGHT / 2, 0) -- na spodním pruhu, vpravo
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 zůstává dost velké, aby se na něj dalo trefit na malém telefonu
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

-- Aktuální průlet: od jednoho CFrame kamery k dalšímu za zadaný počet sekund
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Běží každý snímek během cutscény. Focus u Scriptable kamery sám nic
-- nesleduje, proto se nastavuje také tady.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- něco ho resetovalo, například 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
		-- Jedna už hraje, takže ať server hráče kvůli této hned rozmrazí
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Schováme seznam hráčů, batoh a ukazatel zdraví a zapamatujeme si, co bylo vidět
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- Na telefonech schováme joystick a tlačítko skoku, které jsou v dolních rozích
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- Gamepad umí stisknout jen vybrané tlačítko, proto hráčům s gamepadem vybereme Skip
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- O jeden krok po vlastní aktualizaci kamery Robloxu, jako v tutoriálu Robloxu ke kameře
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- každý průlet začínáme tam, kde kamera právě je
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- Vrátíme kameru postavě hráče
	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 = ""
	-- Zapneme zpět jen to, co vypnula tato cutscéna, zbytku se nedotýkáme
	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) -- server hráče hned rozmrazí
	busy = false
end

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

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

LocalScript ve StarterPlayerScripts se hráči zkopíruje jednou, při vstupu, a běží dál i po respawnu postavy. Proto mají oba ScreenGui vypnuté ResetOnSpawn: kdybyste ho zapnuli, Roblox je při prvním respawnu smaže a tento skript je znovu nevytvoří. Zprávy remote, které přišly dřív, než se skript připojil k OnClientEvent, se zařadí do fronty a doručí se po připojení, takže hráč, který se rychle spawnul, intro stejně uvidí.

Co dělá každá část CutscenePlayer
ČástCo dělá
ScreenGui CutsceneDva černé pruhy, každý na 12 % výšky obrazovky (BAR_HEIGHT), a titulek na spodním pruhu. ScreenInsets None roztáhne pruhy až k samým okrajům obrazovky a DisplayOrder 10 je vykreslí nad ScreenGui s nižším DisplayOrder.
ScreenGui CutsceneControlsObsahuje jen tlačítko Skip, vpravo na spodním pruhu, s UISizeConstraint, který ho drží alespoň na 64 na 32 pixelů, aby se na něj na telefonu dalo snadno trefit. Má výchozí ScreenInsets a obsah nezajede pod tlačítka horní lišty Robloxu ani výřezy kamery. Roblox radí None jen pro obsah, na který se neklepe, proto Skip nemůže být ve ScreenGui s pruhy.
HIDDEN_CORE_GUISSchová seznam hráčů, batoh a ukazatel zdraví přes SetCoreGuiEnabled, předtím si přes GetCoreGuiEnabled zapamatuje, které byly zapnuté, a na konci zapne zpět jen ty, které sám vypnul. Pokud hra schovává batoh jinde, zůstane schovaný, a skript, který je během cutscény zapne, například hlavní menu, nikdo nepřebije.
TouchControlsEnabledNa telefonech a tabletech play nastaví GuiService.TouchControlsEnabled na false po dobu cutscény. Tím se schová joystick a tlačítko skoku, které jsou v dolních rozích, tam, kde je Skip, a na konci se vrátí, pokud byly zapnuté.
updateCameraBěží každý snímek, dokud cutscéna probíhá. Spočítá, jaká část aktuálního průletu uběhla, vyhladí ji přes TweenService:GetValue, postaví kameru mezi dva záběry přes CFrame:Lerp a nastaví Focus 30 studů před kameru.
waitOrSkipČeká dobu průletu a pauzy záběru a každý snímek kontroluje příznak Skip.
playUdělá kameru Scriptable, přehraje záběry popořadě, pak kameru vrátí (CameraType Custom, CameraSubject je Humanoid), zapne zpět core GUI a dotykové ovládání a pošle serveru id cutscény. Pokud druhá cutscéna přijde, zatímco první ještě hraje, hned pošle její id zpět, aby server nedržel hráče na místě kvůli cutscéně, kterou toto zařízení neukázalo.
Tlačítko SkipActivated se spustí kliknutím myši, klepnutím nebo tlačítkem A na gamepadu, když je tlačítko vybrané. Pro hráče, jehož hlavním vstupem je gamepad, play vybere Skip na začátku cutscény a výběr na konci zruší.

Měňte BAR_HEIGHT, aby byly pruhy tenčí nebo tlustší, a EASING_STYLE, abyste změnili pocit z průletů (viz Co kód kamery dělá správně). Titulek i tlačítko Skip mají zapnuté TextScaled, takže text roste a zmenšuje se spolu s obrazovkou.

Krok 4: Cutscéna při dotyku partu

Intro hraje samo. Pro cutscénu na určitém místě mapy, například když hráč poprvé dojde k mostu, přidejte druhou cutscénu a spouštěcí part.

  1. Ve Workspace, Cutscenes vložte Folder s názvem Bridge a rozmístěte jeho záběry jako v kroku 1, s názvy 1 a 2. V řádku pro Command Bar pište Bridge místo Intro.
  2. Najeďte myší na Workspace a vložte Folder s názvem CutsceneTriggers.
  3. Vložte do ní Part s názvem BridgeTrigger. Udělejte ho tak velký, aby hráči nemohli projít kolem, aniž by se ho dotkli, například vysokou širokou desku přes cestu. Zaškrtněte Anchored, odškrtněte CanCollide a CanQuery, nechte CanTouch zaškrtnuté a nastavte Transparency na 1. Vypnuté CanQuery zabrání neviditelné desce blokovat raycasty, například výstřely z návodu ke zbraním. Události dotyku řídí CanTouch, ne CanQuery, takže spouštěč stejně funguje.
  4. Přidejte mu atribut Cutscene typu string a nastavte hodnotu Bridge: název složky, která se má přehrát.

CutsceneService připojí Touched ke každému partu přímo uvnitř CutsceneTriggers při startu serveru, proto spouštěče přidávejte ve Studiu, ne skriptem během hry. Spouštěč s vypnutým CanTouch se přeskočí s varováním v Output, protože Roblox hodí chybu, když skript připojí Touched k takovému partu.

Zatímco postava prochází partem, Touched se spustí mnohokrát za sebou. Tabulka seen a pravidlo „jedna cutscéna najednou“ z toho udělají jednu cutscénu na hráče za server. Hráč, který se dotkne spouštěče během jiné cutscény, se ignoruje a spouštěč pro něj zůstane připravený.

Nedávejte spouštěče na silnice. HumanoidRootPart sedícího hráče je přivařený k sedadlu, a když je jeden part přivařené skupiny ukotvený, Roblox s ním ukotví i ostatní. Hráč, který do spouštěče vjede, proto podrží na místě celé své vozidlo i se spolujezdci, dokud cutscéna neskončí.

Co kód kamery dělá správně

Scriptable, pak zpátky Custom

Skripty kamery Robloxu kamerou nehýbou ani ji neaktualizují, dokud je CameraType Scriptable, a právě to umožňuje CutscenePlayeru ji nastavovat. Na konci vrátí CameraType na Custom a udělá Humanoid hráče CameraSubject, který skripty kamery Robloxu ve výchozím stavu sledují. Provede se to i po Skip, takže hráč nikdy nezůstane koukat na poslední záběr.

Dvě drobné kontroly drží cutscénu u řízení, dokud hraje. Pokud něco uprostřed cutscény nastaví CameraType na jinou hodnotu, funkce, která běží každý snímek, v dalším snímku vrátí Scriptable. A workspace.CurrentCamera skript znovu načte na začátku každé cutscény, protože Roblox vytvoří novou Camera, pokud se současná někdy smaže.

Focus, každý snímek

Camera.Focus říká enginu, které oblasti dát přednost v práci jako osvětlení. Skripty kamery Robloxu ho drží na CameraSubject, ale ne když je kamera Scriptable, a referenční příručka Robloxu říká v tom případě ho aktualizovat každý snímek: dynamické světlo z objektů jako PointLight se daleko od fokusu nemusí vykreslit. CutscenePlayer ho staví 30 studů před kameru (FOCUS_DISTANCE). Zvyšte toto číslo, pokud se vaše záběry dívají na něco vzdálenějšího.

Funkce běží přes RunService:BindToRenderStep, každý snímek před vykreslením, o jeden krok priority po vlastní aktualizaci kamery Robloxu (Enum.RenderPriority.Camera.Value + 1). Tuto prioritu používá tutoriál Robloxu ke kameře, takže cutscéna nastaví kameru až poté, co proběhne vlastní kód kamery Robloxu.

Vyhlazení přes TweenService:GetValue

Tween na camera.CFrame by kamerou hýbal, ale Focus je stejně potřeba nastavovat každý snímek, proto CutscenePlayer hýbe kamerou sám ve stejné funkci. Pro každý průlet spočítá, jaká část času uběhla (od 0 do 1), prožene ji přes TweenService:GetValue se stylem a směrem vyhlazení a postaví kameru na tuto část cesty mezi dvěma záběry přes CFrame:Lerp, který posouvá pozici po přímce a plynule otáčí. GetValue omezí vstup mezi 0 a 1, takže kamera se zastaví přesně na záběru, když doba průletu skončí.

Styly vyhlazení, které se hodí pro průlet kamery
EASING_STYLEJak průlet působí
Enum.EasingStyle.Sine (tady)Rychlost jde po sinusoidě, měkký start a měkké zastavení.
Enum.EasingStyle.QuadJako Sine, ale křivka je o něco ostřejší.
Enum.EasingStyle.LinearStálá rychlost, takže každý průlet začíná i končí v plné rychlosti.

Směr InOut: vyhlazení se v první polovině průletu použije dopředu a ve druhé opačně, takže kamera od jednoho záběru zrychlí a k dalšímu zpomalí.

Streaming

V nových place je instance streaming zapnutý: ve výchozím stavu drží zařízení hráče oblast kolem jeho postavy, takže záběr, který se dívá na druhý konec mapy, může ukázat prázdný svět. CutsceneService žádá Roblox, aby tomuto hráči načetl oblast každého záběru přes Player:RequestStreamAroundAsync: oblast prvního záběru před odesláním události, s čekáním až 2 sekundy, a oblast každého dalšího 2 sekundy předtím, než k němu kamera poletí.

Roblox píše, že oblast bude takto pravděpodobně, ale ne jistě, načtená a že účinek je dočasný. Důležité záběry držte v poloměru streamingu, nebo na serveru použijte Player:AddReplicationFocus pro oblast, která má zůstat načtená, dokud fokus neodeberete. S vypnutým streamingem má zařízení celou mapu tak jako tak a pcall kolem každého požadavku znamená, že neúspěšný požadavek cutscénu nezastaví.

Co je špatně ve starších tutoriálech ke cutscénám

Pokud tento návod porovnáváte s videem nebo příspěvkem na fóru, tady jsou rozdíly, na kterých záleží, a proč je každý postup problém.

Časté postupy v tutoriálech ke cutscénám a co tento návod dělá místo nich
TutoriálProblémTento návod
Hýbe kamerou přes camera:Interpolate()Roblox označil Interpolate jako zastaralý a radí animovat kameru přes TweenService.Každý průlet vyhlazuje přes TweenService:GetValue a kameru nastavuje každý snímek.
Tweenuje camera.CFrame a nic vícFocus zůstane tam, kde ho nechaly skripty kamery, u postavy, takže dynamické světlo daleko od něj se nemusí vykreslit (referenční příručka Robloxu k Camera.Focus).Nastavuje Focus každý snímek v render stepu.
Nevrací kameruHráč uvízne s pohledem na poslední záběr.Na konci nastaví CameraType na Custom a CameraSubject na Humanoid, i po Skip.
Spouští cutscénu z Touched v LocalScriptuNic jí nebrání opakovat se při každém dotyku a rozhodnutí padá na zařízení, které ovládá hráč.Server vybere hráče a pamatuje si, kdo ji už viděl.
Čte party kamery na klientuSe zapnutým streamingem party daleko od postavy na zařízení ještě nemusí existovat.Server čte party, posílá jejich CFrame a žádá o oblast každého záběru krátce předtím, než tam kamera doletí.

Co hráč může a nemůže změnit

Počítejte s tím, že podvodník ovládá všechno na svém zařízení: může CutscenePlayer změnit nebo smazat a poslat CutsceneEvent s jakoukoli hodnotou. Pro cutscénu to skoro nic neznamená, pokud na ní nezávisí nic skutečného.

Co může podvodník zkusit a co z toho vyjde
Podvodník zkoušíVýsledek
Přeskočit cutscénu nebo ji vůbec nepřehrátMůže: je to jeho vlastní obrazovka. Nikdy nedávejte odměnu za „dokoukal cutscénu“.
Poslat CutsceneEvent s jakoukoli hodnotouNěco udělá jen číslo, které odpovídá jeho současné cutscéně, a jediné, co udělá, je, že ho rozmrazí dřív.
Dotknout se spouštěče odkudkoli na mapěMožná: každé zařízení ovládá svou postavu a dokumentace Robloxu o bezpečnosti mezi tím, co může dělat, uvádí podvrhování událostí Touched. Jednou uvidí tuto cutscénu a nic dalšího se nestane.
Hýbat se během cutscény přestoNení co získat. Zmrazení brání poctivým hráčům odejít uprostřed cutscény; není to bezpečnostní kontrola.
Přes remote spustit cutscénu někomu jinémuNemožné. Posílat CutsceneEvent hráči může jen server a jediné, co zařízení může poslat zpět, je „tato cutscéna skončila“.

Pokud cutscéna vede k něčemu skutečnému, například ke dveřím, které se pak otevřou, nebo k objevení bosse, ať to server dělá podle svého časovače, ne když zařízení ohlásí, že cutscéna skončila.

Krok 5: Otestujte

  1. Rozmístěte tři záběry Intro řádkem pro Command Bar. Dejte záběru 1 Caption „Welcome to the village“, záběru 2 MoveSeconds 2.5 a Caption „Find the bridge“ a záběr 3 nechte bez atributů.
  2. Klikněte na Play (F5). Objeví se černé pruhy, kamera se přepne na záběr 1 s jeho titulkem, za 2.5 sekundy doletí k záběru 2 a pak za 3 sekundy k záběru 3 bez titulku. Pak se kamera vrátí za záda postavy a seznam hráčů se znovu objeví. Dokud hraje, chodit nejde.
  3. Zastavte test, znovu klikněte na Play a klikněte na Skip, zatímco kamera letí k záběru 2. Kamera se hned vrátí a můžete hned chodit.
  4. Vejděte do BridgeTrigger: hraje cutscéna Bridge. Projděte jím znovu: nic se nestane.
  5. V rozbalovacím seznamu režimu testu vyberte Server & Clients, nastavte 2 klienty a klikněte na Play. Když Client 1 vejde do spouštěče, cutscéna Bridge hraje jen u Client 1 a Client 2 může chodit.
  6. Nechte Workspace.StreamingEnabled zapnuté a přesuňte jeden záběr daleko od spawnu. Když kamera doletí, okolí má být na místě (pravděpodobně, ale ne zaručeně: viz Streaming).
  7. Pro gamepad zastavte test, klikněte na Play, otevřete Controller Emulator (karta Emulation, pak Controller) a vejděte do BridgeTrigger emulovaným gamepadem: Skip má být vybrané, takže A cutscénu přeskočí. Pokud používáte Device Simulator ve Studiu (v době naší kontroly 15. října 2026 je to beta: zapněte ji ve File, Beta Features, New Device Simulator a restartujte Studio), vyberte telefon, otočte ho na šířku a ověřte, že Skip nezajede pod výřez kamery a dá se na něj snadno trefit a že joystick a tlačítko skoku jsou během cutscény schované.
  8. Pokud jste udělali i hlavní menu, klikněte na Play, pak na tlačítko Play v menu a nechte intro dohrát do konce: potom má být seznam hráčů znovu na obrazovce.

Mějte okno Output (menu Window, pak Output) otevřené po celou dobu. Když vše funguje, tyto skripty nic nevypisují, takže jakékoli varování nebo červená chyba od CutsceneService nebo CutscenePlayer je skutečný problém. Viz Časté chyby.

Jak systém rozšířit

Intro jen při prvním vstupu hráče

Tabulka seen žije jeden server, takže hráč, který se znovu připojí, uvidí intro znovu. Chcete-li ho ukazovat jen při prvním vstupu, ukládejte příznak, například SeenIntro, spolu s ostatními daty hráče přes modul PlayerData z tutoriálu k DataStore. INTRO_CUTSCENE nechte, jak je, a změňte část onCharacterAdded v CutsceneService, která se stará o intro: počkejte, až PlayerData.Get(player) vrátí data hráče, přeskočte intro, pokud je data.SeenIntro true, a nastavte data.SeenIntro = true jen tehdy, když playOnce(player, INTRO_CUTSCENE) vrátil true. Nespouštějte intro z kódu, který načítá data: data se mohou načíst dřív, než se postava spawne, a bez postavy play nic neudělá a příznak se uloží pro intro, které nikdo neviděl.

Postavy, které v cutscéně hrají

Udělejte animaci v Animation Editoru ve Studiu nebo v pluginu třetí strany na animace, například Moon Animator, který zmiňuje dokumentace Robloxu, a přehrajte ji na rigu NPC v záběru, když tam kamera doletí. Referenční příručka Robloxu k Animatoru uvádí, že animace NPC se replikují, jen pokud je načte a spustí server, proto ji přehrávejte ze serverového Scriptu, pokud mají všichni hráči vidět, jak NPC hraje. Pokud ji načtete a spustíte v CutscenePlayeru, animace se nereplikuje, což se hodí pro cutscénu, kterou sleduje jen jeden hráč. Návod ke skriptům animace ukazuje, jak přehrát animaci na NPC ze serverového Scriptu.

Dialogy

Titulky se hodí na krátké repliky, které běží samy. Pro rozhovor, kde hráč odpovídá a vybírá možnosti, viz návod k dialogům s NPC.

Intro po hlavním menu

Návod k hlavnímu menu vypíná CharacterAutoLoads, takže se nikdo nespawne, dokud neklikne na Play. CutsceneService přehrává intro při prvním spawnu hráče, takže s oběma systémy intro hraje při prvním spawnu po Play. Menu zapne core GUI zpět, když se objeví postava, a to se může stát, když už intro hraje, takže během intra může být vidět seznam hráčů. CutscenePlayer zapne zpět jen to, co sám schoval, takže změny menu nechá být a po intru zůstanou zapnuté. Trik s Command Bar z návodu k hlavnímu menu na nasměrování partu kamery je stejný jako v kroku 1.

Průlet mapou na začátku kola

Chcete-li spustit cutscénu z jiného serverového skriptu, například průlet mapou na začátku kola z návodu k systému kol, přidejte do ServerStorage BindableEvent s názvem PlayCutscene. Na konci CutsceneService připojte jeho Event k funkci play a ať ho skript kol volá s každým hráčem a názvem cutscény. play vynechá kontrolu „jednou za server“, takže průlet hraje každé kolo.

Pluginy na cutscény

Pluginy můžete s tímto návodem kombinovat. Pokud plugin na cutscény píše vlastní skript kamery, ověřte, že kameru vrací (CameraType Custom a CameraSubject) a nastavuje Focus, dokud je kamera Scriptable, a rozhodnutí o tom, kdo cutscénu vidí, nechte na serveru jako v tomto návodu.

Časté chyby a řešení

Otevřete okno Output (menu Window, pak Output) před kliknutím na Play. Většina problémů s cutscénami buď vypíše varování tam, nebo vzniká kvůli názvu, který nesedí.

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

CutsceneService čeká na složku s názvem Cutscenes přímo ve Workspace. Vytvořte ji jako v kroku 1 a zkontrolujte pravopis a velké C. Dokud neexistuje, CutsceneService nevytvoří CutsceneEvent, takže čeká i CutscenePlayer.

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

CutscenePlayer čeká na remote, který vytváří CutsceneService. Ověřte, že CutsceneService je Script, ne LocalScript, leží přímo v ServerScriptService, není vypnutý a v Output od něj není chyba ani varování o Cutscenes.

CutsceneService: no folder named Intro in Workspace.Cutscenes

Název v INTRO_CUTSCENE nebo v atributu Cutscene spouštěče neodpovídá žádné složce uvnitř Workspace.Cutscenes. Na velikosti písmen v názvech záleží.

Nic nehraje a v Output je prázdno

Ve složce není part s názvem 1, nebo její party neleží přímo v ní (například uvnitř Model). CutsceneService čte party 1, 2, 3 popořadě a zastaví se na prvním chybějícím čísle. A pamatujte, že každá cutscéna hraje jednou na hráče za server: zastavte test a znovu klikněte na Play.

Kamera se dívá jinam

Kamera se dívá stejným směrem jako přední stěna partu záběru. Natočte kameru Studia na požadovaný pohled a pro tento záběr znovu spusťte řádek pro Command Bar z kroku 1.

Spouštěč nic nedělá

Ověřte, že spouštěcí part leží při startu hry přímo uvnitř Workspace.CutsceneTriggers, že je zaškrtnuté CanTouch (jinak bude v Output varování) a že jeho atribut Cutscene je řetězec s názvem složky ve Workspace.Cutscenes. Opakovaný průchod spouštěčem nic nedělá, tak je to navržené.

Po cutscéně zůstane kamera na posledním záběru

CutscenePlayer se zastavil s chybou dřív, než stihl kameru vrátit, takže hledejte jeho červenou chybu v Output. Kameru může držet i jiný skript, který pořád nastavuje CameraType na Scriptable, například kamera menu, která je pořád navázaná.

Udělat s RoCode

Pokud se vám to nechce stavět ručně, RoCode to může udělat ve vašem otevřeném place. RoCode je nezávislý AI agent pro Roblox Studio, ne od Robloxu: funkci popíšete v jeho webovém chatu a jeho plugin pro Studio vytvoří part a skripty ve vašem Exploreru, takže kód z okna chatu kopírovat nemusíte.

Napíšete

Přidej úvodní cutscénu: složka Cutscenes se složkou Intro a záběry 1 až 3, titulky z atributu Caption, černé pruhy a tlačítko Skip, hraje jednou při prvním spawnu hráče, server drží hráče na místě a na konci se kamera vrátí.

RoCode udělá
  • Může nejdřív prohledat váš place přes Search Scripts, například kvůli skriptu menu nebo kamery, který už nastavuje CameraType, aby se nedostaly do konfliktu
  • Vytvoří složky a spouštěcí part přes Create Instance a nastaví na partech atributy jako Caption a MoveSeconds
  • Napíše CutsceneService a CutscenePlayer přes Create Script
  • Má za úkol kontrolovat každý napsaný skript přes Check Script, který ho ve Studiu zkompiluje bez spuštění, a před každou dávkou změn i po ní vytvoří bod pro vrácení

Party záběrů rozmístěte sami natočením kamery Studia na každý pohled a pak si řekněte o skripty. S pluginem 3.9 nebo novějším může RoCode spustit krátký playtest a přečíst chyby a s pluginem 3.9.11 nebo novějším ovládat testovací postavu, aby ověřil, že hra funguje, ale během hry nepořizuje snímky obrazovky, takže cutscénu si prohlédnete sami. Pořadí, ve kterém stavět celou hru, najdete na stránce jak udělat hru v Robloxu s AI, systém po systému. Jak se RoCode připojuje ke Studiu.

Časté otázky

Jak udělat, aby cutscéna hrála při vstupu do hry?

Pojmenujte složku se záběry Intro ve Workspace.Cutscenes, nebo změňte INTRO_CUTSCENE na název své složky. CutsceneService ji přehraje při prvním spawnu každého hráče na serveru. Chcete-li ji ukazovat jen při úplně prvním vstupu, ukládejte příznak do data store a nastavujte ho až poté, co intro začalo, jak popisuje část Jak systém rozšířit.

Dá se cutscéna udělat bez pluginů?

Ano. Tento návod používá jen party, atributy a dva skripty a řádek pro Command Bar postaví každý záběr přesně tam, kde stojí kamera Studia. Pluginy jako Moon Animator se stejně hodí na animování postav, které v cutscéně hrají.

Proč se kamera v cutscéně nehýbe?

Obvykle je kód kamery v serverovém Scriptu, ale kamerou hráče může hýbat jen LocalScript, protože každé zařízení má vlastní kameru. Další častý důvod: CameraType není Scriptable a standardní skripty kamery Robloxu kameru pořád vracejí k postavě.

Jak zakázat hráči hýbat se během cutscény?

Ukotvěte na serveru jeho HumanoidRootPart, dokud hraje, a potom ho odkotvěte, jak to dělá CutsceneService. Ukotvený part se fyzikou nikdy nepohne. WalkSpeed se přitom nemění, takže to není v konfliktu se skriptem sprintu ani passem na rychlost.

Jak do cutscény přidat tlačítko Skip?

Dejte na obrazovku cutscény TextButton a připojte jeho událost Activated, která se spustí kliknutím, klepnutím nebo tlačítkem A na gamepadu, když je tlačítko vybrané. Skip v CutscenePlayeru nastaví příznak, který smyčka záběrů kontroluje každý snímek, sám se vybere pro hráče s gamepadem a leží ve vlastním ScreenGui s výchozím odsazením, aby ho výřez kamery telefonu nezakryl. Joystick a tlačítko skoku jsou během cutscény schované, takže vedle něj nestojí.

Proč je v cutscéně prázdný svět?

Se zapnutým instance streaming má zařízení hráče jen oblast poblíž jeho postavy. Ať server volá player:RequestStreamAroundAsync pro každý záběr krátce předtím, než tam kamera doletí, jak to dělá CutsceneService. Roblox píše, že oblast bude takto pravděpodobně, ale ne jistě, načtená, proto důležité záběry držte v poloměru streamingu nebo použijte Player:AddReplicationFocus pro oblast, která má zůstat načtená.

Zdroje a další čtení

Jak byl kód ověřen: každý skript na této stránce prochází přísnou kontrolou typů Luau s definicemi Roblox API (luau-lsp, 20. listopadu 2026). Kontrola typů zachytí chyby v názvech API a špatné typy, ale ne chyby v herní logice, proto vše otestujte ve Studiu před publikováním.

Vyzkoušejte RoCode ve své hře.

Kredity zdarma každý den, bez karty. Nainstalujte plugin, popište funkci a podívejte se, co se objeví ve Studiu.