Tutorial · Sisteme de joc

Cum să faci un cutscene în Roblox Studio

Un cutscene în Roblox e o cameră care preia controlul pentru câteva secunde: taie sau zboară lin între cadre, arată o subtitrare și îi dă controlul înapoi jucătorului. În acest ghid construim un cutscene pe care îl configurezi punând part-uri invizibile acolo unde trebuie să stea camera, fără pluginuri. Serverul decide când îl vede jucătorul (la prima apariție sau la atingerea unui trigger), iar dispozitivul jucătorului mișcă camera, arată benzile negre și butonul Skip și readuce camera.

Actualizat 20 noiembrie 202622 min de cititAutor:

Pe scurt

Pune part-uri invizibile ancorate cu numele 1, 2, 3 într-un folder din Workspace.Cutscenes, fiecare cu fața spre unde trebuie să privească camera. Un Script în ServerScriptService le citește CFrame-urile, ține jucătorul pe loc și îi trimite cadrele acelui jucător printr-un RemoteEvent. Un LocalScript în StarterPlayerScripts setează workspace.CurrentCamera.CameraType la Scriptable, la fiecare cadru mișcă camera de la un plan la altul (netezind prin TweenService:GetValue), apoi readuce CameraType la Custom și CameraSubject la Humanoid-ul jucătorului.

  • Camera o poate controla doar dispozitivul jucătorului, așa că codul camerei e un LocalScript. Serverul doar decide cine ce cutscene vede și când.
  • Când camera e Scriptable, Roblox nu mai actualizează Camera.Focus. Referința spune să actualizezi Focus la fiecare cadru, altfel lumina dinamică departe de vechiul focus poate să nu se randeze.
  • Camera:Interpolate e învechit. Referința Roblox spune să animezi camera prin TweenService.
Pe această pagină
  1. Cum funcționează
  2. 1. Cadre
  3. 2. Scriptul de server
  4. 3. LocalScript
  5. 4. Trigger
  6. Detaliile camerei
  7. Tutoriale vechi
  8. Protecție contra trișorilor
  9. 5. Verificare
  10. Extindere
  11. Common errors
  12. Cu RoCode
  13. Întrebări frecvente
  14. Surse și lecturi suplimentare

Cum funcționează un cutscene

IlustrațieUn intro din două cadre la viteză reală: tăietură la primul cadru, pauză de 1 secundă, zbor spre pod în 2.5 secunde, pauză de 1 secundă, apoi camera revine la jucător.

Fiecare dispozitiv al unui jucător are propriul obiect Camera, în workspace.CurrentCamera, așa că ce vede jucătorul poate mișca doar un LocalScript. Să decidă cine ce cutscene vede și când e treaba serverului. Ghidul împarte munca exact așa. Un cutscene decurge așa:

  1. Serverul decide că jucătorul trebuie să vadă un cutscene: Intro la prima apariție pe server sau altul, când atinge un part-trigger.
  2. CutsceneService citește CFrame-urile și setările part-urilor-cadru, îi cere lui Roblox să încarce pentru acel jucător zona primului cadru, ancorează HumanoidRootPart-ul jucătorului ca să stea pe loc și trimite CutsceneEvent doar acelui jucător, cu un id și lista de cadre.
  3. CutscenePlayer de pe dispozitivul jucătorului arată benzile negre și butonul Skip, ascunde lista de jucători, rucsacul, bara de viață și controalele tactile, face camera Scriptable și o mișcă la fiecare cadru.
  4. Când se termină ultimul cadru sau jucătorul apasă Skip, readuce camera la personaj și îi trimite serverului CutsceneEvent cu același id.
  5. Serverul scoate ancorarea jucătorului. Dacă mesajul nu a venit niciodată, o scoate oricum după ce trece lungimea cutscene-ului plus 2 secunde. Cronometrul pornește când serverul trimite cutscene-ul, iar la o intrare lentă dispozitivul poate începe introul cu câteva secunde mai târziu, pentru că un LocalScript din afara ReplicatedFirst nu pornește până nu s-a încărcat jocul. Atunci jucătorul se poate mișca din nou înainte ca introul să se termine pe ecranul lui.
Din ce e alcătuit sistemul de cutscene-uri
ElementUnde se aflăCe face
Script CutsceneServiceServerScriptServiceDecide cine ce cutscene vede și când, citește cadrele, ține jucătorul pe loc și ține minte cine ce a văzut deja.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsRedă cutscene-ul pe ecranul jucătorului: benzi, subtitrări, Skip și mișcarea camerei. La final readuce camera.
RemoteEvent CutsceneEventReplicatedStorage (îl creează CutsceneService)Duce cadrele de la server la un jucător și înapoi mesajul "cutscene-ul s-a terminat".
Folder CutscenesWorkspaceCâte un folder pe cutscene, de exemplu Intro, cu part-urile-cadru 1, 2, 3.
Folder CutsceneTriggersWorkspace (opțional)Part-uri care pornesc un cutscene când jucătorul le atinge.
Explorer-ul când sistemul de cutscene-uri e gata. Folderele Bridge și CutsceneTriggers apar la pasul 4. Când pornește jocul, CutsceneService adaugă în ReplicatedStorage un RemoteEvent numit 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

Pasul 1: așază cadrele camerei

Fiecare cadru e un part invizibil. Camera ia poziția part-ului și se uită în aceeași direcție ca fața lui din față, așa că a pune un cadru înseamnă a pune camera.

  1. În Explorer treci cu mouse-ul peste Workspace, apasă butonul + și inserează un Folder numit Cutscenes. În el inserează un Folder numit Intro. Majusculele din nume contează.
  2. Du camera Studio la prima vedere dorită, ca și cum ai încadra o fotografie.
  3. Inserează un Part în Intro și redenumește-l în 1.
  4. Deschide Command Bar (în fila Script sau prin Window, apoi Script) și rulează workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. În modul de editare, CurrentCamera e vederea prin care te uiți, așa că part-ul ajunge exact în acest cadru. Parantezele și ghilimelele sunt necesare pentru că un nume care începe cu o cifră nu se poate scrie după punct.
  5. În Properties-ul part-ului bifează Anchored, debifează CanCollide, CanTouch și CanQuery și setează Transparency la 1. Anchored îl împiedică să cadă prin hartă; restul îl împiedică să încurce jucătorii, să declanșeze evenimente de atingere și să blocheze raycast-urile.
  6. Repetă pentru vederile următoare, numind part-urile 2, 3 și așa mai departe și schimbând numărul din rândul pentru Command Bar. CutsceneService redă cadrele în ordinea numerelor și se oprește la primul număr lipsă, așa că o gaură în numerotare taie cutscene-ul mai devreme.

Ca să schimbi mai târziu un cadru, du camera la noua vedere și rulează același rând cu numărul acelui cadru. Cu Transparency 1, part-urile sunt invizibile și în Studio, așa că selectează-le din Explorer când ai nevoie de ele.

Fiecare cadru mai poate avea trei atribute opționale. Ca să adaugi un atribut, selectează part-ul, derulează fereastra Properties până la secțiunea Attributes, apasă +, scrie numele, alege tipul și apasă Save.

Atribute opționale pe fiecare part-cadru
AtributTipImplicitCe face
MoveSecondsnumber3Câte secunde zboară camera de la cadrul anterior la acesta. 0 face o tăietură bruscă. Cadrul 1 e mereu o tăietură, așa că pentru el atributul nu are efect.
HoldSecondsnumber1Câte secunde stă camera pe acest cadru după ce ajunge.
CaptionstringnimicTextul de pe banda de jos din momentul în care camera începe să zboare spre acest cadru. Un cadru fără Caption golește textul.

Un număr mai mic decât 0 sau mai mare decât 60, precum și un atribut de tip greșit, se înlocuiesc cu valoarea implicită.

Pasul 2: adaugă scriptul de server

Treci cu mouse-ul peste ServerScriptService, inserează un Script numit CutsceneService și lipește în el codul de mai jos. Setările de sus sunt rândurile pe care le poți schimba.

Script în ServerScriptService cu numele CutsceneService
-- Script în ServerScriptService cu numele CutsceneService.
-- Decide cine ce cutscene vede și când. Citește cadrele camerei din part-urile numerotate
-- din Workspace.Cutscenes, ține jucătorul pe loc și îi spune dispozitivului
-- acelui jucător să redea cadrele. Camera însăși poate fi mișcată doar pe dispozitiv.

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

-- Setări
local INTRO_CUTSCENE = "Intro" -- rulează o dată la prima apariție a jucătorului; "" ca să o dezactivezi
local DEFAULT_MOVE_SECONDS = 3 -- timpul de zbor spre un cadru, dacă nu are MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- timpul pe un cadru, dacă nu are HoldSeconds
local MAX_SHOTS = 30

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

-- Scriptul acesta creează singur CutsceneEvent, așa că nu-l adăuga manual
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-ul cutscene-ului pe care îl urmărește jucătorul
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

-- Cadrele sunt part-urile 1, 2, 3 ... din folderul cu numele cutscene-ului
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,
			-- primul cadru e o tăietură, așa că camera sare direct în el
			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 -- acest cutscene s-a terminat deja
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- un cutscene pe rând
	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

	-- Cu instance streaming activ, dispozitivul jucătorului poate să nu aibă zona
	-- spre care se uită cadrul, iar cererea încarcă zona doar temporar. Încărcăm
	-- acum zona primului cadru (așteptăm până la 2 secunde), iar zona fiecărui cadru următor
	-- cu 2 secunde înainte să zboare camera spre el.
	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 -- jucătorul a ieșit cât se încărca zona
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- secunde de acum până la începutul zborului spre acest cadru
	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
	-- Plasă de siguranță: dezghețăm jucătorul chiar dacă dispozitivul lui nu a răspuns niciodată
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Returnează true doar dacă cutscene-ul a pornit pentru acest jucător
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

-- Dispozitivul jucătorului raportează că cutscene-ul s-a terminat sau a fost sărit
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Part-uri declanșatoare: atingerea pornește cutscene-ul din atributul lor Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Conectarea Touched la un part cu CanTouch dezactivat dă eroare, așa că doar avertizăm
			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 în timpul cutscene-ului, ținem pe loc și noul personaj
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- deja configurat
	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 -- toți cei care au intrat cât scriptul aștepta Cutscenes
	onPlayerAdded(player)
end

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

CutsceneService creează singur RemoteEvent-ul CutsceneEvent imediat ce apare Workspace.Cutscenes, așa că nu trebuie să inserezi nimic manual în ReplicatedStorage. Dacă ai făcut deja un RemoteEvent cu acest nume, șterge-l: LocalScript-ul îl poate găsi pe al tău, pe care nu îl ascultă nimeni pe server.

Setările din partea de sus a CutsceneService
SetareValoarea aiciCe schimbă
INTRO_CUTSCENE"Intro"Folderul din Workspace.Cutscenes care rulează la prima apariție a jucătorului pe server. Pune "" ca să nu existe intro.
DEFAULT_MOVE_SECONDS3Cât durează zborul dacă un cadru nu are atributul MoveSeconds.
DEFAULT_HOLD_SECONDS1Cât stă camera pe un cadru dacă acesta nu are atributul HoldSeconds.
MAX_SHOTS30Cel mai mare număr de cadru pe care CutsceneService îl caută într-un cutscene.

Ce face restul scriptului, în ordine:

  • Citește cadrele pe server. readShots adună CFrame-ul și atributele fiecărui part numerotat într-o listă. Dispozitivul jucătorului primește lista, așa că nu are nevoie de part-uri.
  • Un cutscene pe rând. play nu face nimic cât timp jucătorul urmărește deja un cutscene sau dacă personajul lui nu are Humanoid ori e mort.
  • Fiecare cutscene are propriul id. Dispozitivul trimite id-ul înapoi când cutscene-ul se termină sau e sărit, iar jucătorul e dezghețat doar de id-ul care se potrivește, așa că un mesaj întârziat de la un cutscene anterior nu poate termina unul nou.
  • Ține jucătorul pe loc ancorându-i HumanoidRootPart-ul și ancorează noul personaj dacă jucătorul face respawn în mijlocul cutscene-ului. Referința Roblox spune că un part ancorat nu își schimbă niciodată poziția din cauza gravitației, coliziunilor sau altei fizici. WalkSpeed-ul nu e atins, așa că nu intră în conflict cu un script de sprint sau un pass de viteză. La final scriptul scoate ancorarea de pe root part chiar dacă l-a ancorat alt script, așa că nu ancora personajele în altă parte cât timp poate rula un cutscene.
  • Plasă de siguranță. task.delay dezgheață jucătorul după lungimea completă a cutscene-ului plus 2 secunde, chiar dacă dispozitivul lui nu a răspuns niciodată.
  • Fiecare cutscene o dată pe server. Tabelul seen ține minte, pentru fiecare jucător, ce cutscene-uri au început deja, așa că introul nu se repetă la respawn, iar un cutscene de la un trigger rulează o singură dată. playOnce returnează true doar dacă cutscene-ul chiar a pornit.
  • Configurează fiecare jucător. Bucla peste Players:GetPlayers() de la final îi prinde pe toți cei care au intrat cât scriptul aștepta folderul Cutscenes.

Cadrele pleacă la jucător într-un singur apel FireClient, ca o listă de tabele mici. Pagina Roblox despre remote events spune să nu trimiți un tabel în care sunt amestecate chei numerice și chei text; în lista asta sunt doar chei numerice, iar în fiecare cadru dinăuntru doar chei text, forma recomandată acolo.

Pasul 3: adaugă LocalScript-ul care îl redă

  1. În Explorer deschide StarterPlayer, treci cu mouse-ul peste StarterPlayerScripts și inserează un LocalScript numit CutscenePlayer.
  2. Înlocuiește-i conținutul cu codul de mai jos.
LocalScript în StarterPlayerScripts cu numele CutscenePlayer
-- LocalScript în StarterPlayer > StarterPlayerScripts cu numele CutscenePlayer.
-- Redă cutscene-ul trimis de server: benzi negre, subtitrări, butonul Skip și
-- camera care zboară de la un cadru la altul. Apoi îi dă camera înapoi jucătorului.

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 -- fiecare bandă neagră, ca fracție din înălțimea ecranului
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- câți studs în fața camerei să deseneze Roblox cu cel mai mare detaliu
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 }

-- Ecranul cutscene-ului: două benzi negre și o subtitrare, de la margine la margine. Roblox recomandă
-- ScreenInsets None doar pentru ce nu apasă nimeni, așa că Skip de mai jos are propriul ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- pe tot ecranul
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

-- Butonul Skip are marginile implicite, așa că decupajul camerei nu îl acoperă
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) -- pe banda de jos, în dreapta
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 rămâne destul de mare cât să-l nimerești pe un telefon mic
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

-- Zborul curent: de la un CFrame de cameră la următorul, într-un număr dat de secunde
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Rulează la fiecare cadru în timpul cutscene-ului. Focus-ul unei camere Scriptable nu urmărește
-- nimic singur, așa că îl setăm tot aici.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- ceva l-a resetat, de exemplu 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
		-- Unul rulează deja, așa că lăsăm serverul să dezghețe imediat jucătorul pentru acesta
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Ascundem lista de jucători, rucsacul și bara de viață, ținând minte ce era vizibil
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- Pe telefoane ascundem joystick-ul și butonul de săritură din colțurile de jos
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- Un gamepad poate apăsa doar butonul selectat, așa că pentru jucătorii cu gamepad selectăm Skip
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Cu un pas după propria actualizare a camerei Roblox, ca în tutorialul Roblox despre cameră
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- fiecare zbor pornește de unde e camera acum
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- Îi dăm camera înapoi personajului jucătorului
	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 = ""
	-- Reactivăm doar ce a dezactivat acest cutscene, restul nu-l atingem
	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) -- serverul dezgheață imediat jucătorul
	busy = false
end

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

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

Un LocalScript din StarterPlayerScripts se copiază la jucător o singură dată, la intrare, și continuă să ruleze după respawn-ul personajului. De aceea ambele ScreenGui au ResetOnSpawn dezactivat: dacă îl activezi, Roblox le șterge la primul respawn, iar scriptul acesta nu le mai creează din nou. Mesajele remote-ului sosite înainte ca scriptul să se conecteze la OnClientEvent intră la coadă și sunt livrate după conectare, așa că un jucător care a apărut repede tot vede introul.

Ce face fiecare parte din CutscenePlayer
ParteCe face
ScreenGui CutsceneDouă benzi negre, fiecare de 12% din înălțimea ecranului (BAR_HEIGHT), și subtitrarea pe banda de jos. ScreenInsets None întinde benzile până la marginile ecranului, iar DisplayOrder 10 le desenează peste ScreenGui-urile cu DisplayOrder mai mic.
ScreenGui CutsceneControlsConține doar butonul Skip, în dreapta pe banda de jos, cu un UISizeConstraint care îl ține de cel puțin 64 pe 32 de pixeli, ca să fie ușor de nimerit pe telefon. Are ScreenInsets implicit, iar conținutul nu intră sub butoanele barei de sus Roblox și sub decupajele camerei. Roblox recomandă None doar pentru conținut pe care nu ai ce apăsa, așa că Skip nu poate sta în ScreenGui-ul cu benzile.
HIDDEN_CORE_GUISAscunde lista de jucători, rucsacul și bara de viață prin SetCoreGuiEnabled, după ce a reținut prin GetCoreGuiEnabled care erau activate, iar la final le reactivează doar pe cele pe care le-a dezactivat el. Dacă jocul ascunde rucsacul în altă parte, rămâne ascuns, iar un script care le activează în timpul cutscene-ului, de exemplu meniul principal, nu e anulat.
TouchControlsEnabledPe telefoane și tablete, play setează GuiService.TouchControlsEnabled la false pe durata cutscene-ului. Asta ascunde joystick-ul și butonul de săritură din colțurile de jos, același loc ca Skip, iar la final revin dacă erau activate.
updateCameraRulează la fiecare cadru cât merge cutscene-ul. Calculează ce parte din zborul curent s-a parcurs, o netezește prin TweenService:GetValue, pune camera între două cadre prin CFrame:Lerp și setează Focus la 30 de studs în fața camerei.
waitOrSkipAșteaptă timpul de zbor și pauza cadrului, verificând la fiecare cadru flagul Skip.
playFace camera Scriptable, redă cadrele în ordine, apoi readuce camera (CameraType Custom, CameraSubject e Humanoid-ul), reactivează core GUI-ul și controalele tactile și îi trimite serverului id-ul cutscene-ului. Dacă un al doilea cutscene vine cât primul încă rulează, îi trimite imediat id-ul înapoi, ca serverul să nu țină jucătorul pe loc pentru un cutscene pe care dispozitivul acesta nu l-a arătat.
Butonul SkipActivated se declanșează la un clic de mouse, o atingere sau butonul A de pe gamepad când butonul e selectat. Pentru un jucător al cărui input principal e gamepad-ul, play selectează Skip la începutul cutscene-ului și scoate selecția la final.

Schimbă BAR_HEIGHT ca să faci benzile mai subțiri sau mai groase și EASING_STYLE ca să schimbi senzația zborurilor (vezi Ce face corect codul camerei). Subtitrarea și butonul Skip au TextScaled activat, așa că textul crește și scade odată cu ecranul.

Pasul 4: un cutscene la atingerea unui part

Introul rulează singur. Pentru un cutscene într-un anumit loc de pe hartă, de exemplu când jucătorul ajunge prima dată la pod, adaugă un al doilea cutscene și un part-trigger.

  1. În Workspace, Cutscenes inserează un Folder numit Bridge și așază-i cadrele ca la pasul 1, cu numele 1 și 2. În rândul pentru Command Bar scrie Bridge în loc de Intro.
  2. Treci cu mouse-ul peste Workspace și inserează un Folder numit CutsceneTriggers.
  3. Inserează în el un Part numit BridgeTrigger. Fă-l destul de mare cât jucătorii să nu poată trece pe lângă el fără să-l atingă, de exemplu o placă înaltă și lată de-a curmezișul drumului. Bifează Anchored, debifează CanCollide și CanQuery, lasă CanTouch bifat și setează Transparency la 1. CanQuery dezactivat împiedică placa invizibilă să blocheze raycast-urile, de exemplu împușcăturile din ghidul despre arme. Evenimentele de atingere sunt controlate de CanTouch, nu de CanQuery, așa că triggerul funcționează în continuare.
  4. Adaugă-i un atribut Cutscene de tip string și dă-i valoarea Bridge: numele folderului care trebuie redat.

CutsceneService conectează Touched la fiecare part aflat direct în CutsceneTriggers la pornirea serverului, așa că adaugă triggerele în Studio, nu dintr-un script în timpul jocului. Un trigger cu CanTouch dezactivat e sărit cu un avertisment în Output, pentru că Roblox dă eroare când un script conectează Touched la un astfel de part.

Cât timp personajul trece prin part, Touched se declanșează de multe ori la rând. Tabelul seen și regula "un cutscene pe rând" transformă asta într-un singur cutscene pe jucător pe server. Un jucător care atinge triggerul în timpul altui cutscene e ignorat, iar triggerul rămâne pregătit pentru el.

Nu pune triggere pe drumuri. HumanoidRootPart-ul unui jucător așezat e sudat de scaun, iar când un part dintr-un grup sudat e ancorat, Roblox le ancorează și pe celelalte. Așa că un jucător care intră cu vehiculul într-un trigger ține pe loc tot vehiculul, cu pasageri cu tot, până se termină cutscene-ul.

Ce face corect codul camerei

Scriptable, apoi înapoi la Custom

Scripturile de cameră Roblox nu mișcă și nu actualizează camera cât timp CameraType e Scriptable, iar tocmai asta îi permite lui CutscenePlayer să o poziționeze. La final readuce CameraType la Custom și face Humanoid-ul jucătorului CameraSubject, pe care scripturile de cameră Roblox îl urmăresc implicit. Asta se execută și după Skip, așa că jucătorul nu rămâne niciodată uitându-se la ultimul cadru.

Două verificări mici țin cutscene-ul la comandă cât rulează. Dacă ceva setează CameraType la altă valoare în mijlocul cutscene-ului, funcția care rulează la fiecare cadru pune la loc Scriptable la cadrul următor. Iar workspace.CurrentCamera scriptul îl citește din nou la începutul fiecărui cutscene, pentru că Roblox creează o Camera nouă dacă cea curentă e vreodată ștearsă.

Focus, la fiecare cadru

Camera.Focus îi spune motorului cărei zone să-i dea prioritate în munca precum iluminarea. Scripturile de cameră Roblox îl țin pe CameraSubject, dar nu și când camera e Scriptable, iar referința Roblox spune ca în acest caz să-l actualizezi la fiecare cadru: lumina dinamică de la obiecte precum PointLight poate să nu se randeze departe de focus. CutscenePlayer îl pune la 30 de studs în fața camerei (FOCUS_DISTANCE). Mărește numărul dacă cadrele tale se uită la ceva mai îndepărtat.

Funcția rulează prin RunService:BindToRenderStep, la fiecare cadru înainte de randare, cu un pas de prioritate după propria actualizare a camerei Roblox (Enum.RenderPriority.Camera.Value + 1). Această prioritate o folosește tutorialul Roblox despre cameră, așa că cutscene-ul poziționează camera după ce a rulat propriul cod de cameră al Roblox.

Netezire prin TweenService:GetValue

Un tween pe camera.CFrame ar mișca camera, dar Focus tot trebuie setat la fiecare cadru, așa că CutscenePlayer mișcă singur camera în aceeași funcție. Pentru fiecare zbor calculează ce fracție din timp a trecut (de la 0 la 1), o trece prin TweenService:GetValue cu un stil și o direcție de netezire și pune camera la acea fracție din drumul dintre două cadre prin CFrame:Lerp, care mută poziția în linie dreaptă și rotește lin. GetValue limitează intrarea între 0 și 1, așa că camera se oprește exact pe cadru când se termină timpul de zbor.

Stiluri de netezire potrivite pentru zborul camerei
EASING_STYLECum se simte zborul
Enum.EasingStyle.Sine (aici)Viteza urmează o sinusoidă, pornire lină și oprire lină.
Enum.EasingStyle.QuadCa Sine, dar curba e puțin mai bruscă.
Enum.EasingStyle.LinearViteză constantă, așa că fiecare zbor începe și se termină la viteză maximă.

Direcția InOut: netezirea se aplică înainte în prima jumătate a zborului și invers în a doua, așa că camera accelerează de la un cadru și încetinește spre următorul.

Streaming

În place-urile noi, instance streaming e activ: implicit, dispozitivul jucătorului ține zona din jurul personajului său, așa că un cadru care se uită spre celălalt capăt al hărții poate arăta o lume goală. CutsceneService îi cere lui Roblox să încarce pentru acel jucător zona fiecărui cadru prin Player:RequestStreamAroundAsync: zona primului cadru înainte de trimiterea evenimentului, cu o așteptare de până la 2 secunde, și zona fiecărui cadru următor cu 2 secunde înainte să zboare camera spre el.

Roblox scrie că așa zona va fi probabil, dar nu sigur, încărcată și că efectul e temporar. Ține cadrele importante în raza de streaming sau folosește pe server Player:AddReplicationFocus pentru o zonă care trebuie să rămână încărcată până scoți focusul. Cu streamingul dezactivat, dispozitivul are oricum toată harta, iar pcall-ul din jurul fiecărei cereri înseamnă că o cerere eșuată nu poate opri cutscene-ul.

Ce e greșit în tutorialele vechi despre cutscene-uri

Dacă compari ghidul acesta cu un videoclip sau o postare de pe forum, iată diferențele care contează și de ce fiecare truc e o problemă.

Trucuri frecvente din tutorialele despre cutscene-uri și ce face ghidul acesta în schimb
TutorialulProblemaGhidul acesta
Mișcă camera prin camera:Interpolate()Roblox a marcat Interpolate ca învechit și recomandă animarea camerei prin TweenService.Netezește fiecare zbor prin TweenService:GetValue și poziționează camera la fiecare cadru.
Face tween pe camera.CFrame și nimic altcevaFocus rămâne unde l-au lăsat scripturile de cameră, lângă personaj, așa că lumina dinamică departe de el poate să nu se randeze (referința Roblox pentru Camera.Focus).Setează Focus la fiecare cadru în render step.
Nu readuce cameraJucătorul rămâne blocat uitându-se la ultimul cadru.La final setează CameraType la Custom și CameraSubject pe Humanoid, și după Skip.
Pornește cutscene-ul din Touched într-un LocalScriptNimic nu-l împiedică să se repete la fiecare atingere, iar decizia se ia pe dispozitivul controlat de jucător.Serverul alege jucătorul și ține minte cine l-a văzut deja.
Citește part-urile camerei pe clientCu streamingul activ, part-urile departe de personaj pot încă să nu existe pe dispozitiv.Serverul citește part-urile, trimite CFrame-urile lor și cere zona fiecărui cadru cu puțin înainte să ajungă camera acolo.

Ce poate și ce nu poate schimba jucătorul

Consideră că un trișor controlează tot de pe dispozitivul lui: poate schimba sau șterge CutscenePlayer și poate trimite CutsceneEvent cu orice valoare. Pentru un cutscene asta nu înseamnă aproape nimic, dacă de el nu depinde nimic real.

Ce poate încerca un trișor și ce iese din asta
Trișorul încearcăRezultat
Să sară peste cutscene sau să nu-l redea delocPoate: e propriul lui ecran. Nu da niciodată o recompensă pentru "a urmărit cutscene-ul".
Să trimită CutsceneEvent cu orice valoareFace ceva doar numărul care se potrivește cu cutscene-ul lui curent, iar tot ce face e să-l dezghețe mai devreme.
Să atingă triggerul din orice punct al hărțiiPosibil: fiecare dispozitiv își controlează personajul, iar documentația de securitate Roblox numește falsificarea evenimentelor Touched printre lucrurile pe care le poate face. Va vedea o dată acel cutscene și nu se va mai întâmpla nimic.
Să se miște oricum în timpul cutscene-uluiNu are nimic de câștigat. Înghețarea îi împiedică pe jucătorii cinstiți să plece în mijlocul cutscene-ului; nu e o verificare de securitate.
Să pornească prin remote un cutscene altcuivaImposibil. Doar serverul poate trimite CutsceneEvent unui jucător, iar singurul lucru pe care dispozitivul îl poate trimite înapoi e "acest cutscene s-a terminat".

Dacă un cutscene duce la ceva real, de exemplu la o ușă care apoi se deschide sau la apariția unui boss, lasă serverul să facă asta după propriul cronometru, nu când dispozitivul raportează că cutscene-ul s-a terminat.

Pasul 5: verifică

  1. Așază trei cadre Intro cu rândul pentru Command Bar. Dă-i cadrului 1 Caption "Welcome to the village", cadrului 2 MoveSeconds 2.5 și Caption "Find the bridge", iar cadrul 3 lasă-l fără atribute.
  2. Apasă Play (F5). Apar benzile negre, camera taie la cadrul 1 cu subtitrarea lui, zboară în 2.5 secunde spre cadrul 2, apoi în 3 secunde spre cadrul 3 fără subtitrare. Apoi camera revine în spatele personajului, iar lista de jucători reapare. Cât rulează, nu poți merge.
  3. Oprește testul, apasă din nou Play și apasă Skip cât camera zboară spre cadrul 2. Camera revine imediat și poți merge imediat.
  4. Intră în BridgeTrigger: rulează cutscene-ul Bridge. Treci prin el încă o dată: nu se întâmplă nimic.
  5. Alege Server & Clients din lista derulantă a modului de test, pune 2 clienți și apasă Play. Când Client 1 intră în trigger, cutscene-ul Bridge rulează doar la Client 1, iar Client 2 poate merge.
  6. Lasă Workspace.StreamingEnabled activat și mută un cadru departe de spawn. Când ajunge camera, mediul trebuie să fie la locul lui (probabil, dar nu garantat: vezi Streaming).
  7. Pentru gamepad, oprește testul, apasă Play, deschide Controller Emulator (fila Emulation, apoi Controller) și intră în BridgeTrigger cu gamepad-ul emulat: Skip trebuie să fie selectat, așa că A sare peste cutscene. Dacă folosești Device Simulator din Studio (la verificarea noastră din 15 octombrie 2026 e beta: activeaz-o în File, Beta Features, New Device Simulator și repornește Studio), alege un telefon, întoarce-l orizontal și verifică faptul că Skip nu intră sub decupajul camerei și e ușor de nimerit, iar joystick-ul și butonul de săritură sunt ascunse cât merge cutscene-ul.
  8. Dacă ai făcut și un meniu principal, apasă Play, apoi butonul Play din meniu și lasă introul să ruleze până la capăt: după el lista de jucători trebuie să fie din nou pe ecran.

Ține fereastra Output deschisă (meniul Window, apoi Output) tot timpul. Când totul merge, scripturile acestea nu scriu nimic, așa că orice avertisment sau eroare roșie de la CutsceneService sau CutscenePlayer e o problemă reală. Vezi Erori frecvente.

Cum extinzi sistemul

Intro doar la prima intrare a jucătorului

Tabelul seen trăiește cât un server, așa că un jucător care a reintrat vede din nou introul. Ca să-l arăți doar la prima intrare, salvează un flag, de exemplu SeenIntro, împreună cu celelalte date ale jucătorului prin modulul PlayerData din tutorialul DataStore. Lasă INTRO_CUTSCENE cum e și schimbă partea din onCharacterAdded din CutsceneService care se ocupă de intro: așteaptă până când PlayerData.Get(player) returnează datele jucătorului, sari peste intro dacă data.SeenIntro e true și setează data.SeenIntro = true doar când playOnce(player, INTRO_CUTSCENE) a returnat true. Nu porni introul din codul care încarcă datele: datele se pot încărca înainte să apară personajul, iar fără personaj play nu face nimic, și flagul s-ar salva pentru un intro pe care nu l-a văzut nimeni.

Personaje care joacă în cutscene

Fă o animație în Animation Editor din Studio sau într-un plugin terț de animație, de exemplu Moon Animator, care e menționat în documentația Roblox, și red-o pe rigul unui NPC din cadru când ajunge camera acolo. Referința Roblox pentru Animator spune că animațiile NPC-urilor se replică doar dacă le încarcă și le pornește serverul, așa că red-o dintr-un Script de server dacă toți jucătorii trebuie să vadă cum joacă NPC-ul. Dacă o încarci și o pornești în CutscenePlayer, animația nu se replică, ceea ce e potrivit pentru un cutscene pe care îl urmărește un singur jucător. Ghidul despre scripturi de animație arată cum redai o animație pe un NPC dintr-un Script de server.

Dialoguri

Subtitrările sunt potrivite pentru replici scurte care merg singure. Pentru o conversație în care jucătorul răspunde și alege variante, vezi ghidul despre dialoguri cu NPC-uri.

Intro după meniul principal

Ghidul despre meniul principal dezactivează CharacterAutoLoads, așa că nimeni nu apare până nu apasă Play. CutsceneService redă introul la prima apariție a jucătorului, așa că, cu ambele sisteme, introul rulează la prima apariție după Play. Meniul reactivează core GUI-ul când apare personajul, iar asta se poate întâmpla când introul rulează deja, așa că în timpul introului poate fi vizibilă lista de jucători. CutscenePlayer reactivează doar ce a ascuns el, deci nu atinge modificarea meniului, iar după intro ele rămân activate. Trucul cu Command Bar din ghidul despre meniul principal, pentru poziționarea part-ului camerei, e același ca la pasul 1.

Survol al hărții la începutul rundei

Ca să pornești un cutscene din alt script de server, de exemplu un survol al hărții la începutul rundei din ghidul despre sistemul de runde, adaugă în ServerStorage un BindableEvent numit PlayCutscene. La finalul CutsceneService conectează-i Event-ul la funcția play, iar scriptul de runde să-l apeleze cu fiecare jucător și numele cutscene-ului. play sare peste verificarea "o dată pe server", așa că survolul rulează la fiecare rundă.

Pluginuri pentru cutscene-uri

Pluginurile se pot folosi împreună cu acest ghid. Dacă un plugin de cutscene-uri își scrie propriul script de cameră, verifică dacă readuce camera (CameraType Custom și CameraSubject) și dacă setează Focus cât camera e Scriptable, iar decizia despre cine vede cutscene-ul las-o pe server, ca în acest ghid.

Erori frecvente și soluții

Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play. Cele mai multe probleme cu cutscene-urile fie scriu acolo un avertisment, fie apar din cauza unui nume care nu se potrivește.

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

CutsceneService așteaptă un folder numit Cutscenes direct în Workspace. Creează-l ca la pasul 1 și verifică scrierea și C-ul mare. Cât timp lipsește, CutsceneService nu creează CutsceneEvent, așa că și CutscenePlayer așteaptă.

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

CutscenePlayer așteaptă remote-ul pe care îl creează CutsceneService. Verifică dacă CutsceneService e un Script, nu un LocalScript, stă direct în ServerScriptService, nu e dezactivat și nu are în Output o eroare sau un avertisment despre Cutscenes.

CutsceneService: no folder named Intro in Workspace.Cutscenes

Numele din INTRO_CUTSCENE sau din atributul Cutscene al triggerului nu se potrivește cu niciun folder din Workspace.Cutscenes. Majusculele din nume contează.

Nu rulează nimic, iar Output e gol

Folderul nu are un part numit 1 sau part-urile lui nu stau direct în el (de exemplu, sunt într-un Model). CutsceneService citește part-urile 1, 2, 3 în ordine și se oprește la primul număr lipsă. Și ține minte că fiecare cutscene rulează o dată pe jucător pe server: oprește testul și apasă din nou Play.

Camera se uită în altă parte

Camera se uită în aceeași direcție ca fața din față a part-ului-cadru. Du camera Studio la vederea dorită și rulează din nou rândul pentru Command Bar de la pasul 1 pentru acel cadru.

Triggerul nu face nimic

Verifică dacă part-ul-trigger stă direct în Workspace.CutsceneTriggers când pornește jocul, dacă CanTouch e bifat (altfel apare un avertisment în Output) și dacă atributul lui Cutscene e un string cu numele unui folder din Workspace.Cutscenes. O nouă trecere prin trigger nu face nimic, așa e gândit.

După cutscene camera rămâne pe ultimul cadru

CutscenePlayer s-a oprit cu o eroare înainte să readucă camera, așa că caută o eroare roșie de la el în Output. Camera o poate ține și alt script care setează mereu CameraType la Scriptable, de exemplu o cameră de meniu care e încă legată.

Fă-o cu RoCode

Dacă nu ai chef să construiești asta manual, RoCode o poate face în place-ul pe care îl ai deschis. RoCode este un agent AI independent pentru Roblox Studio, nu de la Roblox: descrii funcția în chatul lui web, iar pluginul lui pentru Studio creează part-ul și scripturile în Explorer-ul tău, așa că nu trebuie să copiezi cod din fereastra de chat.

Tu scrii

Adaugă un cutscene de intro: un folder Cutscenes cu un folder Intro și cadrele de la 1 la 3, subtitrări din atributul Caption, benzi negre și un buton Skip, rulează o dată la prima apariție a jucătorului, serverul ține jucătorul pe loc, iar la final camera revine.

RoCode face
  • Poate verifica întâi place-ul tău prin Search Scripts, de exemplu după un script de meniu sau de cameră care setează deja CameraType, ca să nu intre în conflict
  • Creează folderele și part-ul-trigger prin Create Instance și setează pe part-uri atribute precum Caption și MoveSeconds
  • Scrie CutsceneService și CutscenePlayer prin Create Script
  • Are instrucțiuni să verifice fiecare script scris prin Check Script, care îl compilează în Studio fără să-l ruleze, și pune un punct de anulare înainte și după fiecare lot de modificări

Așază singur part-urile-cadru, ducând camera Studio la fiecare vedere, apoi cere scripturile. Cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.11 sau mai nou poate controla un personaj de test ca să verifice că jocul funcționează, dar în timpul jocului nu face capturi de ecran, așa că cutscene-ul îl urmărești tu. Ordinea în care construiești un joc întreg e pe pagina cum faci un joc în Roblox cu AI, sistem cu sistem. Cum se conectează RoCode la Studio.

Întrebări frecvente

Cum fac un cutscene să ruleze la intrarea în joc?

Numește folderul cu cadre Intro în Workspace.Cutscenes sau schimbă INTRO_CUTSCENE în numele folderului tău. CutsceneService îl redă la prima apariție a fiecărui jucător pe server. Ca să-l arăți doar la prima intrare din toate, salvează un flag într-un data store și setează-l doar după ce introul a început, cum e descris în secțiunea Cum extinzi sistemul.

Pot face un cutscene fără pluginuri?

Da. În ghidul acesta sunt doar part-uri, atribute și două scripturi, iar rândul pentru Command Bar pune fiecare cadru exact acolo unde stă camera Studio. Pluginuri precum Moon Animator sunt totuși utile ca să animezi personajele care joacă în cutscene.

De ce nu se mișcă camera în cutscene?

De obicei codul camerei stă într-un Script de server, dar camera jucătorului o poate mișca doar un LocalScript, pentru că fiecare dispozitiv are propria cameră. Altă cauză frecventă: CameraType nu e Scriptable, iar scripturile standard de cameră Roblox readuc mereu camera la personaj.

Cum îl împiedic pe jucător să se miște în timpul unui cutscene?

Ancorează-i HumanoidRootPart-ul pe server cât rulează și scoate ancorarea după, cum face CutsceneService. Un part ancorat nu se mișcă niciodată din cauza fizicii. WalkSpeed-ul nu e atins, așa că nu intră în conflict cu un script de sprint sau un pass de viteză.

Cum adaug un buton Skip la un cutscene?

Pune un TextButton pe ecranul cutscene-ului și conectează-i evenimentul Activated, care se declanșează la un clic, o atingere sau butonul A de pe gamepad când butonul e selectat. Skip din CutscenePlayer setează un flag pe care bucla de cadre îl verifică la fiecare cadru, se selectează singur pentru jucătorii cu gamepad și stă în propriul ScreenGui cu marginile implicite, ca decupajul camerei telefonului să nu-l acopere. Joystick-ul și butonul de săritură sunt ascunse cât merge cutscene-ul, așa că nu stau lângă el.

De ce e lumea goală în cutscene?

Cu instance streaming activ, dispozitivul jucătorului are doar zona din jurul personajului său. Lasă serverul să apeleze player:RequestStreamAroundAsync pentru fiecare cadru cu puțin înainte să ajungă camera acolo, cum face CutsceneService. Roblox scrie că așa zona va fi probabil, dar nu sigur, încărcată, așa că ține cadrele importante în raza de streaming sau folosește Player:AddReplicationFocus pentru o zonă care trebuie să rămână încărcată.

Surse și lecturi suplimentare

Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.