Poradnik · Systemy gry

Jak zrobić cutscenkę w Roblox Studio

Cutscenka w Roblox to kamera, która na kilka sekund przejmuje sterowanie: przełącza się albo płynnie leci między ujęciami, pokazuje napis i oddaje sterowanie graczowi. W tym poradniku budujemy cutscenkę, którą ustawiasz, rozstawiając niewidoczne party tam, gdzie ma stać kamera, bez pluginów. Serwer decyduje, kiedy gracz ją widzi (przy pierwszym spawnie albo przy dotknięciu wyzwalacza), a urządzenie gracza porusza kamerą, pokazuje czarne pasy i przycisk Skip i oddaje kamerę.

Zaktualizowano 20 listopada 202620 min czytaniaAutor:

W skrócie

Rozstaw niewidoczne zakotwiczone party o nazwach 1, 2, 3 w folderze w Workspace.Cutscenes, każdy przodem tam, gdzie ma patrzeć kamera. Script w ServerScriptService czyta ich CFrame, trzyma gracza w miejscu i wysyła ujęcia temu graczowi przez RemoteEvent. LocalScript w StarterPlayerScripts ustawia workspace.CurrentCamera.CameraType na Scriptable, co klatkę przesuwa kamerę od ujęcia do ujęcia (wygładzając przez TweenService:GetValue), a potem przywraca CameraType na Custom i CameraSubject na Humanoid gracza.

  • Kamerą może sterować tylko urządzenie gracza, więc kod kamery to LocalScript. Serwer tylko decyduje, kto którą cutscenkę widzi i kiedy.
  • Gdy kamera jest Scriptable, Roblox przestaje aktualizować Camera.Focus. W dokumentacji napisano, żeby aktualizować Focus co klatkę, inaczej dynamiczne oświetlenie daleko od starego fokusu może się nie renderować.
  • Camera:Interpolate jest przestarzały. W dokumentacji Roblox napisano, żeby animować kamerę przez TweenService.
Na tej stronie
  1. Jak to działa
  2. 1. Ujęcia
  3. 2. Skrypt serwerowy
  4. 3. LocalScript
  5. 4. Wyzwalacz
  6. Szczegóły kamery
  7. Stare tutoriale
  8. Ochrona przed cheatami
  9. 5. Sprawdzenie
  10. Rozbudowa
  11. Common errors
  12. Z RoCode
  13. Najczęstsze pytania
  14. Źródła i dalsza lektura

Jak działa cutscenka

IlustracjaIntro z dwóch ujęć w prawdziwej prędkości: przełączenie na pierwsze ujęcie, pauza 1 sekunda, przelot do mostu w 2.5 sekundy, pauza 1 sekunda, potem kamera wraca do gracza.

Każde urządzenie gracza ma własny obiekt Camera, w workspace.CurrentCamera, więc przesuwać to, co widzi gracz, może tylko LocalScript. Decydowanie, kto którą cutscenkę widzi i kiedy, to praca serwera. Poradnik dzieli pracę właśnie tak. Jedna cutscenka przebiega tak:

  1. Serwer decyduje, że gracz ma zobaczyć cutscenkę: Intro przy pierwszym spawnie na serwerze albo inną, gdy dotknie partu-wyzwalacza.
  2. CutsceneService czyta CFrame i ustawienia partów-ujęć, prosi Roblox o wczytanie temu graczowi obszaru pierwszego ujęcia, kotwiczy HumanoidRootPart gracza, żeby stał w miejscu, i wysyła CutsceneEvent tylko temu graczowi z id i listą ujęć.
  3. CutscenePlayer na urządzeniu gracza pokazuje czarne pasy i przycisk Skip, chowa listę graczy, plecak, pasek zdrowia i sterowanie dotykowe, robi kamerę Scriptable i przesuwa ją co klatkę.
  4. Gdy ostatnie ujęcie się kończy albo gracz naciska Skip, oddaje kamerę postaci i wysyła serwerowi CutsceneEvent z tym samym id.
  5. Serwer zdejmuje kotwicę z gracza. Jeśli ta wiadomość nigdy nie przyszła, i tak zdejmuje kotwicę, gdy minie długość cutscenki plus 2 sekundy. Timer startuje, gdy serwer wysyła cutscenkę, a przy wolnym wejściu urządzenie może zacząć intro kilka sekund później, bo LocalScript poza ReplicatedFirst nie uruchamia się, dopóki gra się nie wczyta. Wtedy gracz może znowu się ruszać, zanim intro skończy się na jego ekranie.
Z czego składa się system cutscenek
ElementGdzie jestCo robi
Script CutsceneServiceServerScriptServiceDecyduje, kto którą cutscenkę widzi i kiedy, czyta ujęcia, trzyma gracza w miejscu i pamięta, kto co już widział.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsOdtwarza cutscenkę na ekranie gracza: pasy, napisy, Skip i ruch kamery. Na końcu oddaje kamerę.
RemoteEvent CutsceneEventReplicatedStorage (tworzy go CutsceneService)Niesie ujęcia od serwera do jednego gracza, a z powrotem wiadomość "cutscenka się skończyła".
Folder CutscenesWorkspacePo jednym folderze na cutscenkę, na przykład Intro, z partami-ujęciami 1, 2, 3.
Folder CutsceneTriggersWorkspace (opcjonalnie)Party, które uruchamiają cutscenkę, gdy gracz ich dotknie.
Explorer, gdy system cutscenek jest gotowy. Foldery Bridge i CutsceneTriggers pojawiają się w kroku 4. Gdy gra startuje, CutsceneService dodaje do ReplicatedStorage RemoteEvent o nazwie 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: rozstaw ujęcia kamery

Każde ujęcie to niewidoczny part. Kamera bierze pozycję partu i patrzy tam, gdzie jego przednia ściana, więc postawić ujęcie znaczy postawić kamerę.

  1. W Explorerze najedź kursorem na Workspace, kliknij przycisk + i wstaw Folder o nazwie Cutscenes. W nim wstaw Folder o nazwie Intro. Wielkość liter w nazwach ma znaczenie.
  2. Podprowadź kamerę Studio do pierwszego potrzebnego widoku, jakbyś ustawiał kadr do zdjęcia.
  3. Wstaw Part do Intro i zmień jego nazwę na 1.
  4. Otwórz Command Bar (na karcie Script albo przez Window, potem Script) i wykonaj workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. W trybie edycji CurrentCamera to widok, przez który patrzysz, więc part staje dokładnie w tym kadrze. Nawiasy i cudzysłowy są potrzebne, bo nazwy, która zaczyna się od cyfry, nie można pisać po kropce.
  5. W Properties partu zaznacz Anchored, odznacz CanCollide, CanTouch i CanQuery i ustaw Transparency na 1. Anchored nie pozwala mu przelecieć przez mapę; reszta nie pozwala mu przeszkadzać graczom, odpalać eventów dotyku i zasłaniać raycastów.
  6. Powtórz dla kolejnych widoków, nazywając party 2, 3 i tak dalej i zmieniając numer w linii dla Command Bar. CutsceneService odtwarza ujęcia po kolei według numerów i zatrzymuje się na pierwszym brakującym numerze, więc dziura w numeracji urywa cutscenkę przed czasem.

Żeby później zmienić ujęcie, podprowadź kamerę do nowego widoku i wykonaj tę samą linię z numerem tego ujęcia. Z Transparency 1 party są niewidoczne także w Studio, więc wybieraj je w Explorerze, gdy są potrzebne.

Każde ujęcie może mieć jeszcze trzy opcjonalne atrybuty. Żeby dodać atrybut, wybierz part, przewiń okno Properties do sekcji Attributes, kliknij +, wpisz nazwę, wybierz typ i kliknij Save.

Opcjonalne atrybuty na każdym parcie-ujęciu
AtrybutTypDomyślnieCo robi
MoveSecondsnumber3Ile sekund kamera leci od poprzedniego ujęcia do tego. 0 daje ostre przełączenie. Ujęcie 1 to zawsze przełączenie, więc dla niego atrybut nie działa.
HoldSecondsnumber1Ile sekund kamera stoi na tym ujęciu po przylocie.
CaptionstringbrakTekst na dolnym pasie od chwili, gdy kamera zaczyna lecieć do tego ujęcia. Ujęcie bez Caption czyści tekst.

Liczba mniejsza niż 0 albo większa niż 60, a także atrybut złego typu, są zastępowane wartością domyślną.

Krok 2: dodaj skrypt serwerowy

Najedź kursorem na ServerScriptService, wstaw Script o nazwie CutsceneService i wklej do niego kod poniżej. Ustawienia na górze to linie, które możesz zmieniać.

Script w ServerScriptService o nazwie CutsceneService
-- Script w ServerScriptService o nazwie CutsceneService.
-- Decyduje, kto którą cutscenkę widzi i kiedy. Czyta ujęcia kamery z ponumerowanych
-- partów w Workspace.Cutscenes, trzyma gracza w miejscu i mówi urządzeniu
-- tego gracza, żeby odtworzyło ujęcia. Samą kamerą można ruszać tylko na urządzeniu.

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

-- Ustawienia
local INTRO_CUTSCENE = "Intro" -- gra raz przy pierwszym spawnie gracza; "", żeby wyłączyć
local DEFAULT_MOVE_SECONDS = 3 -- czas przelotu do ujęcia, jeśli nie ma MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- czas na ujęciu, jeśli nie ma HoldSeconds
local MAX_SHOTS = 30

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

-- Ten skrypt sam tworzy CutsceneEvent, więc nie dodawaj go ręcznie
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 cutscenki, którą ogląda gracz
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

-- Ujęcia to party 1, 2, 3 ... w folderze o nazwie cutscenki
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,
			-- pierwsze ujęcie to przełączenie, więc kamera od razu do niego skacze
			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 -- ta cutscenka już się skończyła
	end
	playing[player] = nil
	setFrozen(player, false)
end

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

	-- Przy włączonym instance streaming urządzenie gracza może nie mieć obszaru,
	-- na który patrzy ujęcie, a żądanie wczytuje obszar tylko na chwilę. Wczytujemy
	-- obszar pierwszego ujęcia teraz (czekamy do 2 sekund), a obszar każdego następnego
	-- 2 sekundy przed tym, jak kamera do niego poleci.
	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 -- gracz wyszedł, gdy wczytywał się obszar
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- sekund od teraz do początku przelotu do tego ujęcia
	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
	-- Zabezpieczenie: odmrażamy gracza, nawet jeśli jego urządzenie nigdy nie odpowiedziało
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Zwraca true tylko wtedy, gdy cutscenka uruchomiła się dla tego gracza
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

-- Urządzenie gracza zgłasza, że cutscenka się skończyła albo została pominięta
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Party-wyzwalacze: dotknięcie uruchamia cutscenkę z ich atrybutu Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Podłączenie Touched do partu z wyłączonym CanTouch daje błąd, więc tylko ostrzegamy
			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 w trakcie cutscenki, trzymamy w miejscu też nową postać
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- już ustawiony
	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 -- wszyscy, którzy weszli, gdy skrypt czekał na Cutscenes
	onPlayerAdded(player)
end

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

CutsceneService sam tworzy RemoteEvent CutsceneEvent, gdy tylko pojawi się Workspace.Cutscenes, więc ręcznie niczego nie trzeba wstawiać do ReplicatedStorage. Jeśli zrobiłeś już RemoteEvent o tej nazwie, usuń go: LocalScript może znaleźć twój, a jego na serwerze nikt nie nasłuchuje.

Ustawienia na górze CutsceneService
UstawienieWartość tutajCo zmienia
INTRO_CUTSCENE"Intro"Folder w Workspace.Cutscenes, który gra przy pierwszym spawnie gracza na serwerze. Ustaw "", żeby nie było intro.
DEFAULT_MOVE_SECONDS3Ile trwa przelot, jeśli ujęcie nie ma atrybutu MoveSeconds.
DEFAULT_HOLD_SECONDS1Ile kamera stoi na ujęciu, jeśli nie ma ono atrybutu HoldSeconds.
MAX_SHOTS30Największy numer ujęcia, którego CutsceneService szuka w jednej cutscence.

Co robi reszta skryptu, po kolei:

  • Czyta ujęcia na serwerze. readShots zbiera CFrame i atrybuty każdego ponumerowanego partu w listę. Urządzenie gracza dostaje tę listę, więc same party nie są mu potrzebne.
  • Jedna cutscenka naraz. play nic nie robi, gdy gracz już ogląda cutscenkę albo jeśli jego postać nie ma Humanoid lub jest martwa.
  • Każda cutscenka ma własne id. Urządzenie odsyła id, gdy cutscenka się kończy albo jest pominięta, a gracza odmraża tylko zgodne id, więc spóźniona wiadomość od poprzedniej cutscenki nie może zakończyć nowej.
  • Trzyma gracza w miejscu, kotwicząc jego HumanoidRootPart, i kotwiczy nową postać, jeśli gracz respawnuje się w środku cutscenki. W dokumentacji Roblox napisano, że zakotwiczony part nigdy nie zmienia pozycji przez grawitację, zderzenia ani inną fizykę. WalkSpeed nie jest ruszany, więc nie koliduje to ze skryptem sprintu ani passem na prędkość. Na końcu skrypt zdejmuje kotwicę z root part, nawet jeśli zakotwiczył go inny skrypt, więc nie kotwicz postaci gdzie indziej, gdy może trwać cutscenka.
  • Zabezpieczenie. task.delay odmraża gracza po pełnej długości cutscenki plus 2 sekundy, nawet jeśli jego urządzenie nigdy nie odpowiedziało.
  • Każda cutscenka raz na serwer. Tabela seen pamięta dla każdego gracza, które cutscenki już się zaczęły, więc intro nie powtarza się przy respawnie, a cutscenka od wyzwalacza gra raz. playOnce zwraca true tylko wtedy, gdy cutscenka naprawdę się uruchomiła.
  • Ustawia każdego gracza. Pętla po Players:GetPlayers() na końcu łapie wszystkich, którzy weszli, gdy skrypt czekał na folder Cutscenes.

Ujęcia idą do gracza jednym wywołaniem FireClient, jako lista małych tabel. Na stronie Roblox o remote events napisano, żeby nie wysyłać tabeli, w której są wymieszane klucze liczbowe i tekstowe; ta lista ma tylko klucze liczbowe, a każde ujęcie w środku tylko tekstowe, i to jest kształt, który tam zalecają.

Krok 3: dodaj LocalScript, który ją odtwarza

  1. W Explorerze rozwiń StarterPlayer, najedź kursorem na StarterPlayerScripts i wstaw LocalScript o nazwie CutscenePlayer.
  2. Zastąp jego zawartość kodem poniżej.
LocalScript w StarterPlayerScripts o nazwie CutscenePlayer
-- LocalScript w StarterPlayer > StarterPlayerScripts o nazwie CutscenePlayer.
-- Odtwarza cutscenkę, którą przysyła serwer: czarne pasy, napisy, przycisk Skip i
-- kamera lecąca od ujęcia do ujęcia. Potem oddaje kamerę graczowi.

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żdy czarny pas jako część wysokości ekranu
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- ile studów przed kamerą Roblox ma rysować najdokładniej
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 }

-- Ekran cutscenki: dwa czarne pasy i napis, od krawędzi do krawędzi. Roblox radzi ustawiać
-- ScreenInsets None tylko dla tego, czego nikt nie klika, więc Skip niżej ma własny ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- na cały ekran
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

-- Przycisk Skip ma domyślne wcięcia, więc wycięcie kamery go nie zasłania
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 dolnym pasie, po prawej
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 zostaje wystarczająco duży, żeby trafić w niego na małym telefonie
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

-- Bieżący przelot: od jednego CFrame kamery do następnego w zadanej liczbie sekund
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Działa co klatkę w trakcie cutscenki. Focus kamery Scriptable sam za niczym
-- nie podąża, więc też ustawiamy go tutaj.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- coś go zresetowało, na przykład 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 już gra, więc niech serwer od razu odmrozi gracza dla tej
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Chowamy listę graczy, plecak i pasek zdrowia, zapamiętując, co było widoczne
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- Na telefonach chowamy joystick i przycisk skoku, które stoją w dolnych rogach
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- Pad może nacisnąć tylko zaznaczony przycisk, więc dla graczy z padem zaznaczamy Skip
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Jeden krok po własnej aktualizacji kamery Roblox, jak w tutorialu Roblox o kamerze
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- każdy przelot zaczynamy stamtąd, gdzie kamera jest teraz
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- Oddajemy kamerę postaci gracza
	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 = ""
	-- Włączamy z powrotem tylko to, co wyłączyła ta cutscenka, reszty nie ruszamy
	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) -- serwer od razu odmraża gracza
	busy = false
end

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

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

LocalScript w StarterPlayerScripts kopiuje się do gracza raz, przy wejściu, i działa dalej po respawnie postaci. Dlatego oba ScreenGui mają wyłączone ResetOnSpawn: jeśli je włączysz, Roblox usunie je przy pierwszym respawnie, a ten skrypt nie utworzy ich od nowa. Wiadomości remote’a, które przyszły, zanim skrypt podłączył się do OnClientEvent, trafiają do kolejki i są dostarczane po podłączeniu, więc gracz, który szybko się zespawnował, i tak zobaczy intro.

Co robi każda część CutscenePlayer
CzęśćCo robi
ScreenGui CutsceneDwa czarne pasy, każdy po 12% wysokości ekranu (BAR_HEIGHT), i napis na dolnym pasie. ScreenInsets None rozciąga pasy do samych krawędzi ekranu, a DisplayOrder 10 rysuje je nad ScreenGui z mniejszym DisplayOrder.
ScreenGui CutsceneControlsJest w nim tylko przycisk Skip, po prawej na dolnym pasie, z UISizeConstraint, który trzyma go nie mniejszym niż 64 na 32 piksele, żeby łatwo było w niego trafić na telefonie. Ma domyślne ScreenInsets, a zawartość nie wchodzi pod przyciski górnego paska Roblox i wycięcia kamery. Roblox radzi None tylko dla zawartości, której nie ma czego klikać, więc Skip nie może mieszkać w ScreenGui z pasami.
HIDDEN_CORE_GUISChowa listę graczy, plecak i pasek zdrowia przez SetCoreGuiEnabled, wcześniej zapamiętując przez GetCoreGuiEnabled, które były włączone, a na końcu włącza z powrotem tylko te, które sam wyłączył. Jeśli gra chowa plecak gdzie indziej, zostanie schowany, a skryptu, który włącza je w trakcie cutscenki, na przykład menu głównego, nikt nie przebija.
TouchControlsEnabledNa telefonach i tabletach play ustawia GuiService.TouchControlsEnabled na false na czas cutscenki. To chowa joystick i przycisk skoku, które stoją w dolnych rogach, tam gdzie Skip, a na końcu wracają, jeśli były włączone.
updateCameraDziała co klatkę, gdy trwa cutscenka. Liczy, jaka część bieżącego przelotu minęła, wygładza ją przez TweenService:GetValue, stawia kamerę między dwoma ujęciami przez CFrame:Lerp i ustawia Focus 30 studów przed kamerą.
waitOrSkipCzeka czas przelotu i pauzy ujęcia, co klatkę sprawdzając flagę Skip.
playRobi kamerę Scriptable, odtwarza ujęcia po kolei, potem oddaje kamerę (CameraType Custom, CameraSubject to Humanoid), włącza z powrotem core GUI i sterowanie dotykowe i wysyła serwerowi id cutscenki. Jeśli druga cutscenka przychodzi, gdy pierwsza jeszcze gra, od razu odsyła jej id, żeby serwer nie trzymał gracza w miejscu dla cutscenki, której to urządzenie nie pokazało.
Przycisk SkipActivated odpala się na kliknięcie myszą, dotknięcie albo przycisk A na padzie, gdy przycisk jest zaznaczony. Dla gracza, którego głównym wejściem jest pad, play zaznacza Skip na początku cutscenki i zdejmuje zaznaczenie na końcu.

Zmieniaj BAR_HEIGHT, żeby zrobić pasy cieńsze albo grubsze, i EASING_STYLE, żeby zmienić odczucie przelotów (zobacz Co kod kamery robi dobrze). Napis i przycisk Skip mają włączone TextScaled, więc tekst rośnie i maleje razem z ekranem.

Krok 4: cutscenka po dotknięciu partu

Intro gra samo. Dla cutscenki w określonym miejscu mapy, na przykład gdy gracz pierwszy raz dochodzi do mostu, dodaj drugą cutscenkę i part-wyzwalacz.

  1. W Workspace, Cutscenes wstaw Folder o nazwie Bridge i rozstaw jego ujęcia jak w kroku 1, o nazwach 1 i 2. W linii dla Command Bar pisz Bridge zamiast Intro.
  2. Najedź kursorem na Workspace i wstaw Folder o nazwie CutsceneTriggers.
  3. Wstaw do niego Part o nazwie BridgeTrigger. Zrób go na tyle dużym, żeby gracze nie mogli przejść obok, nie dotykając go, na przykład wysoką szeroką płytę w poprzek drogi. Zaznacz Anchored, odznacz CanCollide i CanQuery, zostaw CanTouch zaznaczone i ustaw Transparency na 1. Wyłączone CanQuery nie pozwala niewidocznej płycie zasłaniać raycastów, na przykład strzałów z poradnika o broni. Eventami dotyku steruje CanTouch, a nie CanQuery, więc wyzwalacz i tak działa.
  4. Dodaj mu atrybut Cutscene typu string i ustaw wartość Bridge: nazwę folderu, który ma zagrać.

CutsceneService podłącza Touched do każdego partu bezpośrednio w CutsceneTriggers przy starcie serwera, więc dodawaj wyzwalacze w Studio, a nie skryptem w trakcie gry. Wyzwalacz z wyłączonym CanTouch jest pomijany z ostrzeżeniem w Output, bo Roblox daje błąd, gdy skrypt podłącza Touched do takiego partu.

Gdy postać idzie przez part, Touched odpala się wiele razy z rzędu. Tabela seen i zasada "jedna cutscenka naraz" zamieniają to w jedną cutscenkę na gracza na serwer. Gracz, który dotyka wyzwalacza w trakcie innej cutscenki, jest ignorowany, a wyzwalacz zostaje dla niego gotowy.

Nie stawiaj wyzwalaczy na drogach. HumanoidRootPart siedzącego gracza jest przyspawany do siedzenia, a gdy jeden part przyspawanej grupy jest zakotwiczony, Roblox kotwiczy razem z nim resztę. Dlatego gracz, który wjeżdża w wyzwalacz, trzyma w miejscu cały swój pojazd, razem z pasażerami, dopóki cutscenka się nie skończy.

Co kod kamery robi dobrze

Scriptable, potem z powrotem Custom

Skrypty kamery Roblox nie ruszają ani nie aktualizują kamery, dopóki CameraType to Scriptable, i właśnie to pozwala CutscenePlayer ją ustawiać. Na końcu przywraca CameraType na Custom i ustawia Humanoid gracza jako CameraSubject, którego skrypty kamery Roblox domyślnie śledzą. Dzieje się to także po Skip, więc gracz nigdy nie zostaje, patrząc na ostatnie ujęcie.

Dwa małe sprawdzenia trzymają cutscenkę w roli głównej, gdy gra. Jeśli coś ustawi CameraType na inną wartość w środku cutscenki, funkcja, która działa co klatkę, w następnej klatce przywraca Scriptable. A workspace.CurrentCamera skrypt czyta od nowa na początku każdej cutscenki, bo Roblox tworzy nową Camera, jeśli bieżąca kiedyś zostanie usunięta.

Focus, co klatkę

Camera.Focus mówi silnikowi, któremu obszarowi dawać priorytet w pracy takiej jak oświetlenie. Skrypty kamery Roblox trzymają go na CameraSubject, ale nie wtedy, gdy kamera jest Scriptable, a w dokumentacji Roblox napisano, żeby w takim przypadku aktualizować go co klatkę: dynamiczne światło od obiektów w rodzaju PointLight może się nie renderować daleko od fokusu. CutscenePlayer stawia go 30 studów przed kamerą (FOCUS_DISTANCE). Zwiększ tę liczbę, jeśli twoje ujęcia patrzą na coś dalej.

Funkcja działa przez RunService:BindToRenderStep, co klatkę przed renderowaniem, jeden krok priorytetu po własnej aktualizacji kamery Roblox (Enum.RenderPriority.Camera.Value + 1). Tego priorytetu używa tutorial Roblox o kamerze, więc cutscenka ustawia kamerę po tym, jak zadziałał własny kod kamery Roblox.

Wygładzanie przez TweenService:GetValue

Tween na camera.CFrame przesuwałby kamerę, ale Focus i tak trzeba ustawiać co klatkę, więc CutscenePlayer sam przesuwa kamerę w tej samej funkcji. Dla każdego przelotu liczy, jaka część czasu minęła (od 0 do 1), przepuszcza ją przez TweenService:GetValue ze stylem i kierunkiem wygładzania i stawia kamerę w tej części drogi między dwoma ujęciami przez CFrame:Lerp, który przesuwa pozycję po prostej i płynnie obraca. GetValue ogranicza wejście między 0 a 1, więc kamera zatrzymuje się dokładnie na ujęciu, gdy kończy się czas przelotu.

Style wygładzania, które pasują do przelotu kamery
EASING_STYLEJak odczuwa się przelot
Enum.EasingStyle.Sine (tutaj)Prędkość idzie po sinusoidzie, miękki start i miękkie zatrzymanie.
Enum.EasingStyle.QuadJak Sine, ale krzywa jest trochę ostrzejsza.
Enum.EasingStyle.LinearStała prędkość, więc każdy przelot zaczyna się i kończy na pełnej prędkości.

Kierunek InOut: wygładzanie działa do przodu w pierwszej połowie przelotu i w drugą stronę w drugiej, więc kamera rozpędza się od jednego ujęcia i zwalnia przy następnym.

Streaming

W nowych grach instance streaming jest włączony: domyślnie urządzenie gracza trzyma obszar wokół jego postaci, więc ujęcie, które patrzy na drugi kraniec mapy, może pokazać pusty świat. CutsceneService prosi Roblox o wczytanie temu graczowi obszaru każdego ujęcia przez Player:RequestStreamAroundAsync: obszaru pierwszego ujęcia przed wysłaniem eventu, z czekaniem do 2 sekund, i obszaru każdego następnego 2 sekundy przed tym, jak kamera do niego poleci.

Roblox pisze, że w ten sposób obszar prawdopodobnie, ale nie na pewno, zostanie wczytany i że efekt jest tymczasowy. Trzymaj ważne ujęcia w promieniu streamingu albo używaj na serwerze Player:AddReplicationFocus dla obszaru, który ma zostać wczytany, dopóki nie usuniesz fokusu. Z wyłączonym streamingiem urządzenie i tak ma całą mapę, a pcall wokół każdego żądania oznacza, że nieudane żądanie nie może zatrzymać cutscenki.

Co jest nie tak w starych tutorialach o cutscenkach

Jeśli porównujesz ten poradnik z filmem albo postem na forum, oto różnice, które mają znaczenie, i dlaczego każdy sposób to problem.

Częste sposoby w tutorialach o cutscenkach i co ten poradnik robi zamiast nich
TutorialProblemTen poradnik
Przesuwa kamerę przez camera:Interpolate()Roblox oznaczył Interpolate jako przestarzały i radzi animować kamerę przez TweenService.Wygładza każdy przelot przez TweenService:GetValue i ustawia kamerę co klatkę.
Tweenuje camera.CFrame i nic więcejFocus zostaje tam, gdzie zostawiły go skrypty kamery, przy postaci, więc dynamiczne światło daleko od niego może się nie renderować (dokumentacja Roblox o Camera.Focus).Ustawia Focus co klatkę w render step.
Nie oddaje kameryGracz utyka, patrząc na ostatnie ujęcie.Na końcu ustawia CameraType na Custom i CameraSubject na Humanoid, także po Skip.
Uruchamia cutscenkę z Touched w LocalScriptNic nie przeszkadza jej powtarzać się przy każdym dotknięciu, a decyzja zapada na urządzeniu, którym steruje gracz.Serwer wybiera gracza i pamięta, kto już ją widział.
Czyta party kamery na klienciePrzy włączonym streamingu party daleko od postaci mogą jeszcze nie istnieć na urządzeniu.Serwer czyta party, wysyła ich CFrame i prosi o obszar każdego ujęcia na chwilę przed tym, jak przyleci tam kamera.

Co gracz może, a czego nie może zmienić

Zakładaj, że oszust kontroluje wszystko na swoim urządzeniu: może zmienić albo usunąć CutscenePlayer i wysłać CutsceneEvent z dowolną wartością. Dla cutscenki prawie nic to nie znaczy, jeśli nie zależy od niej nic prawdziwego.

Czego może spróbować oszust i co z tego wyjdzie
Oszust próbujeWynik
Pominąć cutscenkę albo w ogóle jej nie odtwarzaćMoże: to jego własny ekran. Nigdy nie dawaj nagrody za "obejrzał cutscenkę".
Wysłać CutsceneEvent z dowolną wartościąCoś robi tylko liczba zgodna z jego bieżącą cutscenką, a jedyne, co robi, to odmraża go wcześniej.
Dotknąć wyzwalacza z dowolnego miejsca mapyMożliwe: każde urządzenie steruje swoją postacią, a w dokumentacji Roblox o bezpieczeństwie podrabianie eventów Touched wymieniono wśród tego, co może robić. Raz zobaczy tę cutscenkę i nic więcej się nie stanie.
Mimo wszystko ruszać się w trakcie cutscenkiNie ma nic do wygrania. Zamrożenie nie pozwala uczciwym graczom odchodzić w środku cutscenki; to nie jest sprawdzenie bezpieczeństwa.
Przez remote uruchomić cutscenkę komuś innemuNiemożliwe. Wysyłać CutsceneEvent graczowi może tylko serwer, a jedyne, co urządzenie może odesłać, to "ta cutscenka się skończyła".

Jeśli cutscenka prowadzi do czegoś prawdziwego, na przykład do drzwi, które potem się otwierają, albo do pojawienia się bossa, niech serwer robi to według własnego timera, a nie wtedy, gdy urządzenie zgłasza, że cutscenka się skończyła.

Krok 5: sprawdź

  1. Rozstaw trzy ujęcia Intro linią dla Command Bar. Daj ujęciu 1 Caption "Welcome to the village", ujęciu 2 MoveSeconds 2.5 i Caption "Find the bridge", a ujęcie 3 zostaw bez atrybutów.
  2. Kliknij Play (F5). Pojawiają się czarne pasy, kamera przełącza się na ujęcie 1 z jego napisem, w 2.5 sekundy leci do ujęcia 2, potem w 3 sekundy do ujęcia 3 bez napisu. Potem kamera wraca za plecy postaci, a lista graczy pojawia się znowu. Gdy gra, nie można chodzić.
  3. Zatrzymaj test, znowu kliknij Play i naciśnij Skip, gdy kamera leci do ujęcia 2. Kamera od razu wraca i od razu można chodzić.
  4. Wejdź w BridgeTrigger: gra cutscenka Bridge. Przejdź przez niego jeszcze raz: nic się nie dzieje.
  5. Wybierz Server & Clients na liście trybu testu, ustaw 2 klientów i kliknij Play. Gdy Client 1 wchodzi w wyzwalacz, cutscenka Bridge gra tylko u Client 1, a Client 2 może chodzić.
  6. Zostaw Workspace.StreamingEnabled włączone i odnieś jedno ujęcie daleko od spawnu. Gdy kamera przyleci, otoczenie powinno być na miejscu (prawdopodobnie, ale nie na pewno: zobacz Streaming).
  7. Dla pada zatrzymaj test, kliknij Play, otwórz Controller Emulator (karta Emulation, potem Controller) i wejdź w BridgeTrigger emulowanym padem: Skip powinien być zaznaczony, więc A pomija cutscenkę. Jeśli korzystasz z Device Simulator w Studio (w chwili naszego sprawdzenia 15 października 2026 roku to beta: włącz ją w File, Beta Features, New Device Simulator i uruchom Studio ponownie), wybierz telefon, obróć go poziomo i sprawdź, czy Skip nie wchodzi pod wycięcie kamery i łatwo w niego trafić, a joystick i przycisk skoku są schowane, gdy trwa cutscenka.
  8. Jeśli zrobiłeś też menu główne, kliknij Play, potem przycisk Play w menu i pozwól intro dograć do końca: po nim lista graczy powinna znowu być na ekranie.

Trzymaj okno Output otwarte (menu Window, potem Output) przez cały czas. Gdy wszystko działa, te skrypty nic nie wypisują, więc każde ostrzeżenie albo czerwony błąd od CutsceneService lub CutscenePlayer to prawdziwy problem. Zobacz Częste błędy.

Jak rozbudować system

Intro tylko przy pierwszym wejściu gracza

Tabela seen żyje jeden serwer, więc gracz, który wszedł ponownie, znowu widzi intro. Żeby pokazywać je tylko przy pierwszym wejściu, zapisuj flagę, na przykład SeenIntro, razem z resztą danych gracza przez moduł PlayerData z poradnika o DataStore. Zostaw INTRO_CUTSCENE bez zmian i zmień część onCharacterAdded w CutsceneService, która odpowiada za intro: poczekaj, aż PlayerData.Get(player) zwróci dane gracza, pomiń intro, jeśli data.SeenIntro jest true, i ustawiaj data.SeenIntro = true tylko wtedy, gdy playOnce(player, INTRO_CUTSCENE) zwróciło true. Nie uruchamiaj intro z kodu, który wczytuje dane: dane mogą się wczytać, zanim zespawnuje się postać, a bez postaci play nic nie robi i flaga zapisze się dla intro, którego nikt nie widział.

Postacie, które grają w cutscence

Zrób animację w Animation Editor w Studio albo w zewnętrznym pluginie do animacji, na przykład Moon Animator, o którym wspomina dokumentacja Roblox, i odtwórz ją na rigu NPC w ujęciu, gdy przyleci tam kamera. W dokumentacji Roblox o Animator napisano, że animacje NPC replikują się tylko wtedy, gdy wczytuje i uruchamia je serwer, więc odtwarzaj ją z serwerowego Script, jeśli wszyscy gracze mają widzieć, jak gra NPC. Jeśli wczytasz i uruchomisz ją w CutscenePlayer, animacja się nie replikuje, a to pasuje do cutscenki, którą ogląda tylko jeden gracz. Poradnik o skryptach animacji pokazuje, jak odtworzyć animację na NPC z serwerowego Script.

Dialogi

Napisy pasują do krótkich kwestii, które lecą same. Dla rozmowy, w której gracz odpowiada i wybiera opcje, zobacz poradnik o dialogach z NPC.

Intro po menu głównym

Poradnik o menu głównym wyłącza CharacterAutoLoads, więc nikt się nie spawnuje, dopóki nie kliknie Play. CutsceneService odtwarza intro przy pierwszym spawnie gracza, więc z oboma systemami intro gra przy pierwszym spawnie po Play. Menu włącza core GUI z powrotem, gdy pojawia się postać, a to może się stać, gdy intro już gra, więc w trakcie intro może być widać listę graczy. CutscenePlayer włącza z powrotem tylko to, co sam schował, więc zmiany menu nie rusza, a po intro zostają one włączone. Sztuczka z Command Bar z poradnika o menu głównym do ustawiania partu kamery jest ta sama co w kroku 1.

Przelot nad mapą na początku rundy

Żeby uruchomić cutscenkę z innego serwerowego skryptu, na przykład przelot nad mapą na początku rundy z poradnika o systemie rund, dodaj do ServerStorage BindableEvent o nazwie PlayCutscene. Na końcu CutsceneService podłącz jego Event do funkcji play, a skrypt rund niech wywołuje go z każdym graczem i nazwą cutscenki. play pomija sprawdzenie "raz na serwer", więc przelot gra w każdej rundzie.

Pluginy do cutscenek

Pluginów można używać razem z tym poradnikiem. Jeśli plugin do cutscenek pisze własny skrypt kamery, sprawdź, czy oddaje kamerę (CameraType Custom i CameraSubject) i ustawia Focus, gdy kamera jest Scriptable, a decyzję o tym, kto widzi cutscenkę, zostaw serwerowi, jak w tym poradniku.

Częste błędy i rozwiązania

Otwórz okno Output (menu Window, potem Output) przed kliknięciem Play. Większość problemów z cutscenkami albo wypisuje tam ostrzeżenie, albo bierze się z nazwy, która się nie zgadza.

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

CutsceneService czeka na folder o nazwie Cutscenes bezpośrednio w Workspace. Utwórz go jak w kroku 1 i sprawdź pisownię i wielkie C. Dopóki go nie ma, CutsceneService nie tworzy CutsceneEvent, więc CutscenePlayer też czeka.

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

CutscenePlayer czeka na remote, który tworzy CutsceneService. Sprawdź, czy CutsceneService to Script, a nie LocalScript, leży bezpośrednio w ServerScriptService, nie jest wyłączony i czy w Output nie ma od niego błędu albo ostrzeżenia o Cutscenes.

CutsceneService: no folder named Intro in Workspace.Cutscenes

Nazwa w INTRO_CUTSCENE albo w atrybucie Cutscene wyzwalacza nie zgadza się z żadnym folderem w Workspace.Cutscenes. Wielkość liter w nazwach ma znaczenie.

Nic nie gra, a Output jest pusty

W folderze nie ma partu o nazwie 1 albo jego party nie leżą bezpośrednio w nim (na przykład są w Model). CutsceneService czyta party 1, 2, 3 po kolei i zatrzymuje się na pierwszym brakującym numerze. I pamiętaj, że każda cutscenka gra raz na gracza na serwer: zatrzymaj test i znowu kliknij Play.

Kamera patrzy nie tam

Kamera patrzy tam, gdzie przednia ściana partu-ujęcia. Podprowadź kamerę Studio do potrzebnego widoku i znowu wykonaj linię dla Command Bar z kroku 1 dla tego ujęcia.

Wyzwalacz nic nie robi

Sprawdź, czy part-wyzwalacz leży bezpośrednio w Workspace.CutsceneTriggers, gdy gra startuje, czy CanTouch jest zaznaczone (inaczej w Output będzie ostrzeżenie) i czy jego atrybut Cutscene to string z nazwą folderu w Workspace.Cutscenes. Ponowne przejście przez wyzwalacz nic nie robi, tak jest zamierzone.

Po cutscence kamera zostaje na ostatnim ujęciu

CutscenePlayer zatrzymał się z błędem, zanim zdążył oddać kamerę, więc szukaj od niego czerwonego błędu w Output. Kamerę może też trzymać inny skrypt, który cały czas ustawia CameraType na Scriptable, na przykład kamera menu, która jest wciąż podpięta.

Zrób to z RoCode

Jeśli nie chce ci się składać tego ręcznie, RoCode może to zrobić w grze, którą masz otwartą. RoCode to niezależny agent AI do Roblox Studio, nie robi go Roblox: opisujesz funkcję na jego czacie w przeglądarce, a jego plugin do Studio tworzy part i skrypty w twoim Explorerze, więc nie musisz kopiować kodu z okna czatu.

Ty piszesz

Dodaj cutscenkę wprowadzającą: folder Cutscenes z folderem Intro i ujęciami od 1 do 3, napisy z atrybutu Caption, czarne pasy i przycisk Skip, gra raz przy pierwszym spawnie gracza, serwer trzyma gracza w miejscu, a na końcu kamera wraca.

RoCode robi
  • Może najpierw sprawdzić twoją grę przez Search Scripts, na przykład pod kątem skryptu menu albo kamery, który już ustawia CameraType, żeby się nie kłóciły
  • Tworzy foldery i part-wyzwalacz przez Create Instance i ustawia na partach atrybuty, takie jak Caption i MoveSeconds
  • Pisze CutsceneService i CutscenePlayer przez Create Script
  • Ma polecone sprawdzać każdy napisany skrypt przez Check Script, który kompiluje go w Studio bez uruchamiania, i stawia punkt cofania przed i po każdej paczce zmian

Rozstaw party-ujęcia sam, podprowadzając kamerę Studio do każdego widoku, a potem proś o skrypty. Z pluginem 3.9 lub nowszym RoCode może uruchomić krótki playtest i przeczytać błędy, a z pluginem 3.9.11 lub nowszym może sterować testową postacią, żeby sprawdzić, czy gra działa, ale w trakcie gry nie robi zrzutów ekranu, więc cutscenkę oglądasz sam. Kolejność budowania całej gry jest na stronie jak zrobić grę w Roblox z AI, system po systemie. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Jak sprawić, żeby cutscenka grała przy wejściu do gry?

Nazwij folder z ujęciami Intro w Workspace.Cutscenes albo zmień INTRO_CUTSCENE na nazwę swojego folderu. CutsceneService odtwarza ją przy pierwszym spawnie każdego gracza na serwerze. Żeby pokazywać ją tylko przy pierwszym wejściu w ogóle, zapisuj flagę w data store i ustawiaj ją dopiero po tym, jak intro się zaczęło, jak opisano w sekcji Jak rozbudować system.

Czy można zrobić cutscenkę bez pluginów?

Tak. W tym poradniku są tylko party, atrybuty i dwa skrypty, a linia dla Command Bar stawia każde ujęcie dokładnie tam, gdzie stoi kamera Studio. Pluginy w rodzaju Moon Animator i tak przydają się do animowania postaci, które grają w cutscence.

Dlaczego kamera nie rusza się w cutscence?

Zwykle kod kamery leży w serwerowym Script, a ruszać kamerą gracza może tylko LocalScript, bo każde urządzenie ma własną kamerę. Inna częsta przyczyna: CameraType nie jest Scriptable, a standardowe skrypty kamery Roblox cały czas przywracają kamerę do postaci.

Jak zabronić graczowi ruszania się w trakcie cutscenki?

Zakotwicz jego HumanoidRootPart na serwerze, gdy gra, i zdejmij kotwicę potem, jak robi CutsceneService. Zakotwiczony part nigdy nie rusza się od fizyki. WalkSpeed nie jest przy tym ruszany, więc nie koliduje to ze skryptem sprintu ani passem na prędkość.

Jak dodać przycisk Skip do cutscenki?

Włóż TextButton na ekran cutscenki i podłącz jego event Activated, który odpala się na kliknięcie, dotknięcie albo przycisk A na padzie, gdy przycisk jest zaznaczony. Skip w CutscenePlayer ustawia flagę, którą pętla ujęć sprawdza co klatkę, sam się zaznacza dla graczy z padem i leży we własnym ScreenGui z domyślnymi wcięciami, żeby wycięcie kamery telefonu go nie zasłaniało. Joystick i przycisk skoku są schowane, gdy trwa cutscenka, więc nie stoją obok niego.

Dlaczego w cutscence jest pusty świat?

Przy włączonym instance streaming urządzenie gracza ma tylko obszar blisko jego postaci. Niech serwer wywołuje player:RequestStreamAroundAsync dla każdego ujęcia na chwilę przed tym, jak przyleci tam kamera, jak robi CutsceneService. Roblox pisze, że w ten sposób obszar prawdopodobnie, ale nie na pewno, zostanie wczytany, więc trzymaj ważne ujęcia w promieniu streamingu albo używaj Player:AddReplicationFocus dla obszaru, który ma zostać wczytany.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.