Tutorial · Sistemi di gioco

Come fare una cutscene in Roblox Studio

Una cutscene su Roblox è la camera che prende il controllo per qualche secondo: passa da un'inquadratura all'altra di colpo o con un movimento fluido, mostra una didascalia e restituisce il controllo al giocatore. In questa guida costruiamo una cutscene che configuri piazzando parti invisibili dove deve stare la camera, senza plugin. Il server decide quando il giocatore la vede (al primo spawn o quando tocca un trigger), e il dispositivo del giocatore muove la camera, mostra le bande nere e il pulsante Skip e restituisce la camera.

Aggiornato il 20 novembre 202624 min di letturaScritto da

In breve

Piazza parti invisibili e ancorate chiamate 1, 2, 3 in una cartella dentro Workspace.Cutscenes, ognuna rivolta dove deve guardare la camera. Uno Script in ServerScriptService legge il loro CFrame, tiene fermo il giocatore e invia le inquadrature a quel giocatore tramite un RemoteEvent. Un LocalScript in StarterPlayerScripts imposta workspace.CurrentCamera.CameraType su Scriptable, a ogni frame muove la camera da un'inquadratura all'altra (con l'easing di TweenService:GetValue) e alla fine rimette CameraType su Custom e CameraSubject sullo Humanoid del giocatore.

  • Solo il dispositivo del giocatore può controllare la camera, quindi il codice della camera è un LocalScript. Il server decide solo chi vede quale cutscene e quando.
  • Quando la camera è Scriptable, Roblox smette di aggiornare Camera.Focus. Il riferimento dice di aggiornare Focus a ogni frame, altrimenti l'illuminazione dinamica lontana dal vecchio focus potrebbe non essere disegnata.
  • Camera:Interpolate è deprecato. Il riferimento di Roblox dice di animare la camera con TweenService.
In questa pagina
  1. Come funziona
  2. 1. Inquadrature
  3. 2. Script del server
  4. 3. LocalScript
  5. 4. Trigger
  6. Dettagli della camera
  7. Vecchi tutorial
  8. Protezione dai cheat
  9. 5. Prova
  10. Estensioni
  11. Common errors
  12. Con RoCode
  13. Domande frequenti
  14. Fonti e letture

Come funziona una cutscene

IllustrazioneUn'intro di due inquadrature a velocità reale: passaggio alla prima inquadratura, pausa di 1 secondo, movimento verso il ponte in 2.5 secondi, pausa di 1 secondo, poi la camera torna al giocatore.

Ogni dispositivo del giocatore ha il proprio oggetto Camera, in workspace.CurrentCamera, quindi solo un LocalScript può muovere ciò che vede il giocatore (in inglese). Decidere chi vede quale cutscene e quando è compito del server. La guida divide il lavoro proprio così. Una cutscene si svolge in questo modo:

  1. Il server decide che il giocatore deve vedere una cutscene: Intro al primo spawn sul server, oppure un'altra quando tocca una parte trigger.
  2. CutsceneService legge il CFrame e le impostazioni delle parti inquadratura, chiede a Roblox di caricare per quel giocatore la zona della prima inquadratura, ancora lo HumanoidRootPart del giocatore perché resti fermo e invia CutsceneEvent solo a quel giocatore con un id e la lista delle inquadrature.
  3. CutscenePlayer sul dispositivo del giocatore mostra le bande nere e il pulsante Skip, nasconde la lista dei giocatori, lo zaino, la barra della salute e i controlli touch, rende la camera Scriptable e la muove a ogni frame.
  4. Quando finisce l'ultima inquadratura o il giocatore preme Skip, restituisce la camera al personaggio e invia al server CutsceneEvent con lo stesso id.
  5. Il server toglie l'ancoraggio al giocatore. Se quel messaggio non arriva mai, toglie comunque l'ancoraggio quando è passata la durata della cutscene più 2 secondi. Il timer parte quando il server invia la cutscene, e con un ingresso lento il dispositivo può iniziare l'intro qualche secondo dopo, perché un LocalScript fuori da ReplicatedFirst non parte finché il gioco non è caricato. In quel caso il giocatore può tornare a muoversi prima che l'intro finisca sul suo schermo.
Di cosa è fatto il sistema di cutscene
ElementoDove si trovaCosa fa
Script CutsceneServiceServerScriptServiceDecide chi vede quale cutscene e quando, legge le inquadrature, tiene fermo il giocatore e ricorda chi ha già visto cosa.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsRiproduce la cutscene sullo schermo del giocatore: bande, didascalie, Skip e movimento della camera. Alla fine restituisce la camera.
RemoteEvent CutsceneEventReplicatedStorage (lo crea CutsceneService)Porta le inquadrature dal server a un giocatore e, nell'altra direzione, il messaggio "la cutscene è finita".
Folder CutscenesWorkspaceUna cartella per cutscene, per esempio Intro, con le parti inquadratura 1, 2, 3.
Folder CutsceneTriggersWorkspace (facoltativa)Parti che avviano una cutscene quando il giocatore le tocca.
L'Explorer quando il sistema di cutscene è pronto. Le cartelle Bridge e CutsceneTriggers compaiono nel passo 4. Quando il gioco parte, CutsceneService aggiunge a ReplicatedStorage un RemoteEvent chiamato 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

Passo 1: Piazza le inquadrature della camera

Ogni inquadratura è una parte invisibile. La camera prende la posizione della parte e guarda nella stessa direzione della sua faccia frontale, quindi piazzare un'inquadratura significa piazzare la camera.

  1. Nell'Explorer passa il mouse su Workspace, clicca sul pulsante + e inserisci una Folder chiamata Cutscenes. Dentro inserisci una Folder chiamata Intro. Maiuscole e minuscole nei nomi contano.
  2. Porta la camera di Studio sulla prima vista che vuoi, come se componessi l'inquadratura per una foto.
  3. Inserisci una Part in Intro e rinominala 1.
  4. Apri la Command Bar (nella scheda Script oppure da Window, poi Script) ed esegui workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. In modalità modifica CurrentCamera è la vista attraverso cui stai guardando, quindi la parte si mette esattamente in quell'inquadratura. Parentesi e virgolette servono perché un nome che inizia con una cifra non si può scrivere dopo un punto.
  5. Nelle Properties della parte spunta Anchored, togli la spunta a CanCollide, CanTouch e CanQuery e imposta Transparency a 1. Anchored le impedisce di cadere attraverso la mappa; il resto le impedisce di ostacolare i giocatori, attivare eventi di tocco e bloccare i raycast.
  6. Ripeti per le viste successive, chiamando le parti 2, 3 e così via e cambiando il numero nella riga per la Command Bar. CutsceneService riproduce le inquadrature in ordine numerico e si ferma al primo numero mancante, quindi un buco nella numerazione interrompe la cutscene prima del tempo.

Per cambiare un'inquadratura più avanti, porta la camera sulla nuova vista ed esegui la stessa riga con il numero di quell'inquadratura. Con Transparency 1 le parti sono invisibili anche in Studio, quindi selezionale nell'Explorer quando ti servono.

Ogni inquadratura può avere altri tre attributi facoltativi. Per aggiungere un attributo, seleziona la parte, scorri la finestra Properties fino alla sezione Attributes, clicca su +, scrivi il nome, scegli il tipo e clicca su Save.

Attributi facoltativi su ogni parte inquadratura
AttributoTipoPredefinitoCosa fa
MoveSecondsnumber3Quanti secondi la camera impiega a spostarsi dall'inquadratura precedente a questa. 0 fa uno stacco netto. L'inquadratura 1 è sempre uno stacco, quindi per lei l'attributo non ha effetto.
HoldSecondsnumber1Quanti secondi la camera resta su questa inquadratura dopo esserci arrivata.
CaptionstringnessunoTesto sulla banda inferiore dal momento in cui la camera inizia a spostarsi verso questa inquadratura. Un'inquadratura senza Caption cancella il testo.

Un numero minore di 0 o maggiore di 60, così come un attributo del tipo sbagliato, viene sostituito dal valore predefinito.

Passo 2: Aggiungi lo script del server

Passa il mouse su ServerScriptService, inserisci uno Script chiamato CutsceneService e incolla il codice qui sotto. Le impostazioni in alto sono le righe che puoi cambiare.

Script in ServerScriptService chiamato CutsceneService
-- Script in ServerScriptService chiamato CutsceneService.
-- Decide chi vede quale cutscene e quando. Legge le inquadrature della camera dalle
-- parti numerate in Workspace.Cutscenes, tiene fermo il giocatore e dice al dispositivo
-- di quel giocatore di riprodurre le inquadrature. La camera si può muovere solo sul dispositivo.

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

-- Impostazioni
local INTRO_CUTSCENE = "Intro" -- parte una volta al primo spawn del giocatore; "" per disattivarla
local DEFAULT_MOVE_SECONDS = 3 -- durata dello spostamento verso un'inquadratura senza MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- durata della pausa su un'inquadratura senza HoldSeconds
local MAX_SHOTS = 30

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

-- Questo script crea da solo CutsceneEvent, quindi non aggiungerlo a mano
local cutsceneEvent = Instance.new("RemoteEvent")
cutsceneEvent.Name = "CutsceneEvent"
cutsceneEvent.Parent = ReplicatedStorage

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

local seen: { [Player]: { [string]: boolean } } = {}
local playing: { [Player]: number } = {} -- id della cutscene che il giocatore sta guardando
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

-- Le inquadrature sono le parti 1, 2, 3 ... nella cartella con il nome della cutscene
local function readShots(name: string): { Shot }
	local shots: { Shot } = {}
	local folder = cutscenes:FindFirstChild(name)
	if not folder then
		warn(`CutsceneService: no folder named {name} in Workspace.Cutscenes`)
		return shots
	end
	for index = 1, MAX_SHOTS do
		local part = folder:FindFirstChild(tostring(index))
		if not (part and part:IsA("BasePart")) then
			break
		end
		local caption = part:GetAttribute("Caption")
		table.insert(shots, {
			cframe = part.CFrame,
			-- la prima inquadratura è uno stacco, quindi la camera ci salta subito
			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 -- questa cutscene è già finita
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- una cutscene alla volta
	end
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then
		return false
	end
	local shots = readShots(name)
	if #shots == 0 then
		return false
	end

	lastId += 1
	local id = lastId
	playing[player] = id

	-- Con l'instance streaming attivo il dispositivo del giocatore potrebbe non avere la zona
	-- che l'inquadratura guarda, e la richiesta carica la zona solo temporaneamente. Carichiamo
	-- la zona della prima inquadratura adesso (aspettando fino a 2 secondi) e quella di ogni
	-- inquadratura successiva 2 secondi prima che la camera si sposti lì.
	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 -- il giocatore è uscito mentre la zona si caricava
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- secondi da adesso all'inizio dello spostamento verso questa inquadratura
	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
	-- Rete di sicurezza: sblocchiamo il giocatore anche se il suo dispositivo non risponde mai
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- Restituisce true solo se la cutscene è partita per questo giocatore
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

-- Il dispositivo del giocatore comunica che la cutscene è finita o è stata saltata
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- Parti trigger: il tocco avvia la cutscene indicata nel loro attributo Cutscene
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- Collegare Touched a una parte con CanTouch disattivato dà errore, quindi diamo solo un avviso
			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 durante la cutscene, teniamo fermo anche il nuovo personaggio
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- già configurato
	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 -- tutti quelli entrati mentre lo script aspettava Cutscenes
	onPlayerAdded(player)
end

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

CutsceneService crea da solo il RemoteEvent CutsceneEvent non appena esiste Workspace.Cutscenes, quindi non serve inserire nulla a mano in ReplicatedStorage. Se hai già creato un RemoteEvent con quel nome, eliminalo: il LocalScript potrebbe trovare il tuo, che sul server nessuno ascolta.

Le impostazioni in cima a CutsceneService
ImpostazioneValore quiCosa cambia
INTRO_CUTSCENE"Intro"La cartella in Workspace.Cutscenes che parte al primo spawn del giocatore sul server. Imposta "" per non avere un'intro.
DEFAULT_MOVE_SECONDS3Quanto dura uno spostamento se l'inquadratura non ha l'attributo MoveSeconds.
DEFAULT_HOLD_SECONDS1Quanto la camera resta su un'inquadratura se non ha l'attributo HoldSeconds.
MAX_SHOTS30Il numero di inquadratura più alto che CutsceneService cerca in una cutscene.

Cosa fa il resto dello script, in ordine:

  • Legge le inquadrature sul server. readShots raccoglie in una lista il CFrame e gli attributi di ogni parte numerata. Il dispositivo del giocatore riceve questa lista, quindi le parti stesse non gli servono.
  • Una cutscene alla volta. play non fa nulla se il giocatore sta già guardando una cutscene, o se il suo personaggio non ha uno Humanoid o è morto.
  • Ogni cutscene ha il suo id. Il dispositivo rimanda l'id quando la cutscene finisce o viene saltata, e solo un id corrispondente sblocca il giocatore, quindi un messaggio in ritardo di una cutscene precedente non può chiudere quella nuova.
  • Tiene fermo il giocatore ancorando il suo HumanoidRootPart, e ancora il nuovo personaggio se il giocatore fa respawn a metà cutscene. Il riferimento di Roblox dice che una parte ancorata non cambia mai posizione per gravità, collisioni o altra fisica. WalkSpeed non viene toccata, quindi non va in conflitto con uno script di corsa o un pass di velocità. Alla fine lo script toglie l'ancoraggio alla root part anche se l'aveva ancorata un altro script, quindi non ancorare i personaggi altrove mentre può essere in corso una cutscene.
  • Rete di sicurezza. task.delay sblocca il giocatore dopo la durata completa della cutscene più 2 secondi, anche se il suo dispositivo non risponde mai.
  • Ogni cutscene una volta per server. La tabella seen ricorda per ogni giocatore quali cutscene sono già iniziate, quindi l'intro non si ripete al respawn e una cutscene da trigger parte una volta sola. playOnce restituisce true solo se la cutscene è partita davvero.
  • Configura ogni giocatore. Il ciclo su Players:GetPlayers() alla fine prende tutti quelli entrati mentre lo script aspettava la cartella Cutscenes.

Le inquadrature arrivano al giocatore con una sola chiamata FireClient, come lista di piccole tabelle. La pagina di Roblox sui remote event dice di non inviare una tabella con chiavi numeriche e di testo mescolate; questa lista ha solo chiavi numeriche e ogni inquadratura al suo interno solo chiavi di testo, che è la forma consigliata lì.

Passo 3: Aggiungi il LocalScript che la riproduce

  1. Nell'Explorer espandi StarterPlayer, passa il mouse su StarterPlayerScripts e inserisci un LocalScript chiamato CutscenePlayer.
  2. Sostituisci il suo contenuto con il codice qui sotto.
LocalScript in StarterPlayerScripts chiamato CutscenePlayer
-- LocalScript in StarterPlayer > StarterPlayerScripts chiamato CutscenePlayer.
-- Riproduce la cutscene inviata dal server: bande nere, didascalie, pulsante Skip e
-- camera che si sposta da un'inquadratura all'altra. Poi restituisce la camera al giocatore.

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 -- ogni banda nera, come frazione dell'altezza dello schermo
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- a quanti stud davanti alla camera Roblox deve disegnare con più dettaglio
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 }

-- Schermata della cutscene: due bande nere e una didascalia, da bordo a bordo. Roblox consiglia
-- ScreenInsets None solo per ciò che nessuno preme, quindi Skip qui sotto ha il suo ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- a tutto schermo
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

-- Il pulsante Skip ha i margini predefiniti, quindi il notch della fotocamera non lo copre
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) -- sulla banda inferiore, a destra
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 resta abbastanza grande da poterlo premere su un telefono piccolo
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

-- Lo spostamento attuale: da un CFrame della camera al successivo in un dato numero di secondi
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- Gira a ogni frame durante la cutscene. Il Focus di una camera Scriptable non segue
-- niente da solo, quindi viene impostato anche qui.
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- qualcosa l'ha reimpostato, per esempio 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
		-- Ne sta già girando una, quindi il server sblocchi subito il giocatore per questa
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- Nascondiamo lista giocatori, zaino e barra della salute, ricordando cosa era visibile
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- Sui telefoni nascondiamo lo stick e il pulsante di salto, che stanno negli angoli in basso
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- Un gamepad può premere solo il pulsante selezionato, quindi per chi usa il gamepad selezioniamo Skip
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Un passo dopo l'aggiornamento della camera di Roblox, come nel tutorial di Roblox sulla camera
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- ogni spostamento parte da dove si trova ora la camera
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- Restituiamo la camera al personaggio del giocatore
	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 = ""
	-- Riattiviamo solo ciò che questa cutscene ha disattivato, il resto non lo tocchiamo
	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) -- il server sblocca subito il giocatore
	busy = false
end

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

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

Un LocalScript in StarterPlayerScripts viene copiato al giocatore una sola volta, all'ingresso, e continua a funzionare dopo il respawn del personaggio. Per questo entrambi gli ScreenGui hanno ResetOnSpawn disattivato: se lo attivi, Roblox li elimina al primo respawn e questo script non li ricrea. I messaggi del remote arrivati prima che lo script si colleghi a OnClientEvent vengono messi in coda e consegnati dopo il collegamento, quindi anche un giocatore che fa spawn in fretta vede l'intro.

Cosa fa ogni parte di CutscenePlayer
ParteCosa fa
ScreenGui CutsceneDue bande nere, ognuna alta il 12% dello schermo (BAR_HEIGHT), e la didascalia sulla banda inferiore. ScreenInsets None estende le bande fino ai bordi dello schermo, e DisplayOrder 10 le disegna sopra gli ScreenGui con DisplayOrder più basso.
ScreenGui CutsceneControlsContiene solo il pulsante Skip, a destra sulla banda inferiore, con un UISizeConstraint che lo tiene ad almeno 64 per 32 pixel perché sia facile da premere su un telefono. Ha gli ScreenInsets predefiniti, e il contenuto non finisce sotto i pulsanti della barra in alto di Roblox o sotto i notch delle fotocamere. Roblox consiglia None solo per contenuti che non si premono, quindi Skip non può stare nello ScreenGui con le bande.
HIDDEN_CORE_GUISNasconde lista giocatori, zaino e barra della salute con SetCoreGuiEnabled, dopo aver ricordato con GetCoreGuiEnabled quali erano attivi, e alla fine riattiva solo quelli che ha disattivato lui. Se il gioco nasconde lo zaino altrove, resta nascosto, e uno script che li attiva durante la cutscene, per esempio un menu principale, non viene sovrascritto.
TouchControlsEnabledSu telefoni e tablet play imposta GuiService.TouchControlsEnabled a false per la durata della cutscene. Questo nasconde lo stick e il pulsante di salto, che stanno negli angoli in basso, nello stesso punto di Skip, e alla fine tornano se erano attivi.
updateCameraGira a ogni frame finché la cutscene è in corso. Calcola quanta parte dello spostamento attuale è passata, la ammorbidisce con TweenService:GetValue, mette la camera tra le due inquadrature con CFrame:Lerp e imposta Focus a 30 stud davanti alla camera.
waitOrSkipAspetta il tempo dello spostamento e della pausa dell'inquadratura, controllando il flag di Skip a ogni frame.
playRende la camera Scriptable, riproduce le inquadrature in ordine, poi restituisce la camera (CameraType Custom, CameraSubject è lo Humanoid), riattiva le core GUI e i controlli touch e invia al server l'id della cutscene. Se arriva una seconda cutscene mentre la prima è ancora in corso, rimanda subito il suo id, così il server non tiene fermo il giocatore per una cutscene che questo dispositivo non ha mostrato.
Pulsante SkipActivated scatta con un clic del mouse, un tap o il pulsante A del gamepad quando il pulsante è selezionato. Per un giocatore il cui input principale è il gamepad, play seleziona Skip all'inizio della cutscene e toglie la selezione alla fine.

Cambia BAR_HEIGHT per rendere le bande più sottili o più spesse, ed EASING_STYLE per cambiare la sensazione degli spostamenti (vedi Cosa fa bene il codice della camera). La didascalia e il pulsante Skip hanno TextScaled attivo, quindi il testo cresce e si rimpicciolisce insieme allo schermo.

Passo 4: Una cutscene al tocco di una parte

L'intro parte da sola. Per una cutscene in un punto preciso della mappa, per esempio quando il giocatore arriva per la prima volta al ponte, aggiungi una seconda cutscene e una parte trigger.

  1. In Workspace, Cutscenes inserisci una Folder chiamata Bridge e piazza le sue inquadrature come nel passo 1, con i nomi 1 e 2. Nella riga per la Command Bar scrivi Bridge invece di Intro.
  2. Passa il mouse su Workspace e inserisci una Folder chiamata CutsceneTriggers.
  3. Inseriscici una Part chiamata BridgeTrigger. Falla abbastanza grande che i giocatori non possano passare senza toccarla, per esempio una lastra alta e larga di traverso sulla strada. Spunta Anchored, togli la spunta a CanCollide e CanQuery, lascia spuntato CanTouch e imposta Transparency a 1. CanQuery disattivato impedisce alla lastra invisibile di bloccare i raycast, per esempio i colpi della guida alle armi (in inglese). Gli eventi di tocco dipendono da CanTouch, non da CanQuery, quindi il trigger funziona lo stesso.
  4. Aggiungile un attributo Cutscene di tipo string con valore Bridge: il nome della cartella da riprodurre.

CutsceneService collega Touched a ogni parte direttamente dentro CutsceneTriggers all'avvio del server, quindi aggiungi i trigger in Studio, non con uno script durante il gioco. Un trigger con CanTouch disattivato viene saltato con un avviso nell'Output, perché Roblox dà errore quando uno script collega Touched a una parte del genere.

Mentre il personaggio attraversa la parte, Touched scatta molte volte di fila. La tabella seen e la regola "una cutscene alla volta" trasformano tutto questo in una cutscene per giocatore per server. Un giocatore che tocca il trigger durante un'altra cutscene viene ignorato, e il trigger resta pronto per lui.

Non mettere trigger sulle strade per veicoli. Lo HumanoidRootPart di un giocatore seduto è saldato al sedile, e quando una parte di un gruppo saldato è ancorata, Roblox ancora insieme a lei anche le altre. Quindi un giocatore che entra nel trigger con un veicolo tiene fermo tutto il veicolo, passeggeri compresi, finché la cutscene non finisce.

Cosa fa bene il codice della camera

Scriptable, poi di nuovo Custom

Gli script della camera di Roblox non muovono né aggiornano la camera finché CameraType è Scriptable, ed è proprio questo che permette a CutscenePlayer di posizionarla. Alla fine rimette CameraType su Custom e rende lo Humanoid del giocatore il CameraSubject, che gli script della camera di Roblox seguono di default. Questo succede anche dopo Skip, quindi il giocatore non resta mai a guardare l'ultima inquadratura.

Due piccoli controlli mantengono la cutscene al comando mentre è in corso. Se qualcosa imposta CameraType su un altro valore a metà cutscene, la funzione che gira a ogni frame rimette Scriptable al frame successivo. E lo script rilegge workspace.CurrentCamera all'inizio di ogni cutscene, perché Roblox crea una nuova Camera se quella attuale viene eliminata.

Focus, a ogni frame

Camera.Focus dice al motore a quale zona dare la priorità in lavori come l'illuminazione. Gli script della camera di Roblox lo tengono sul CameraSubject, ma non quando la camera è Scriptable, e il riferimento di Roblox dice in quel caso di aggiornarlo a ogni frame: la luce dinamica di oggetti come PointLight potrebbe non essere disegnata lontano dal focus. CutscenePlayer lo mette a 30 stud davanti alla camera (FOCUS_DISTANCE). Aumenta questo numero se le tue inquadrature guardano qualcosa di più lontano.

La funzione gira tramite RunService:BindToRenderStep, a ogni frame prima del rendering, un passo di priorità dopo l'aggiornamento della camera di Roblox (Enum.RenderPriority.Camera.Value + 1). È la priorità usata dal tutorial di Roblox sulla camera, quindi la cutscene posiziona la camera dopo che il codice della camera di Roblox ha fatto il suo lavoro.

Easing con TweenService:GetValue

Un tween su camera.CFrame muoverebbe la camera, ma Focus va comunque impostato a ogni frame, quindi CutscenePlayer muove la camera da sé nella stessa funzione. Per ogni spostamento calcola quale frazione del tempo è passata (da 0 a 1), la passa a TweenService:GetValue con uno stile e una direzione di easing e mette la camera a quella frazione del percorso tra le due inquadrature con CFrame:Lerp, che muove la posizione in linea retta e ruota in modo fluido. GetValue limita l'input tra 0 e 1, quindi la camera si ferma esattamente sull'inquadratura quando il tempo dello spostamento finisce.

Stili di easing adatti a uno spostamento della camera
EASING_STYLECome si percepisce lo spostamento
Enum.EasingStyle.Sine (qui)La velocità segue una sinusoide, partenza morbida e arresto morbido.
Enum.EasingStyle.QuadCome Sine, ma con una curva un po' più netta.
Enum.EasingStyle.LinearVelocità costante, quindi ogni spostamento inizia e finisce a piena velocità.

La direzione InOut: l'easing si applica in avanti nella prima metà dello spostamento e al contrario nella seconda, quindi la camera accelera lasciando un'inquadratura e rallenta arrivando alla successiva.

Streaming

Nei place nuovi l'instance streaming è attivo: di default il dispositivo del giocatore tiene la zona intorno al suo personaggio, quindi un'inquadratura che guarda l'altro capo della mappa può mostrare un mondo vuoto. CutsceneService chiede a Roblox di caricare per quel giocatore la zona di ogni inquadratura con Player:RequestStreamAroundAsync: la zona della prima inquadratura prima di inviare l'evento, aspettando fino a 2 secondi, e la zona di ogni inquadratura successiva 2 secondi prima che la camera ci si sposti.

Roblox scrive che così la zona sarà probabilmente, ma non sicuramente, caricata, e che l'effetto è temporaneo. Tieni le inquadrature importanti entro il raggio di streaming oppure usa sul server Player:AddReplicationFocus per una zona che deve restare caricata finché non togli il focus. Con lo streaming disattivato il dispositivo ha comunque tutta la mappa, e il pcall intorno a ogni richiesta fa sì che una richiesta fallita non possa fermare la cutscene.

Cosa non va nei vecchi tutorial sulle cutscene

Se confronti questa guida con un video o un post sul forum, ecco le differenze che contano e perché ogni trucco è un problema.

Trucchi comuni nei tutorial sulle cutscene e cosa fa invece questa guida
TutorialProblemaQuesta guida
Muove la camera con camera:Interpolate()Roblox ha segnato Interpolate come deprecato e consiglia di animare la camera con TweenService.Ammorbidisce ogni spostamento con TweenService:GetValue e posiziona la camera a ogni frame.
Fa un tween di camera.CFrame e nient'altroFocus resta dove l'hanno lasciato gli script della camera, vicino al personaggio, quindi la luce dinamica lontana potrebbe non essere disegnata (riferimento di Roblox su Camera.Focus).Imposta Focus a ogni frame nel render step.
Non restituisce la cameraIl giocatore resta bloccato a guardare l'ultima inquadratura.Alla fine mette CameraType su Custom e CameraSubject sullo Humanoid, anche dopo Skip.
Avvia la cutscene da Touched in un LocalScriptNiente le impedisce di ripetersi a ogni tocco, e la decisione viene presa sul dispositivo controllato dal giocatore.Il server sceglie il giocatore e ricorda chi l'ha già vista.
Legge le parti della camera sul clientCon lo streaming attivo le parti lontane dal personaggio potrebbero non esistere ancora sul dispositivo.Il server legge le parti, invia il loro CFrame e chiede la zona di ogni inquadratura poco prima che la camera ci arrivi.

Cosa il giocatore può e non può cambiare

Considera che un cheater controlla tutto sul proprio dispositivo: può modificare o eliminare CutscenePlayer e inviare CutsceneEvent con qualsiasi valore. Per una cutscene questo non significa quasi nulla, se non ci dipende niente di reale.

Cosa può tentare un cheater e cosa ne esce
Il cheater tenta diRisultato
Saltare la cutscene o non riprodurla affattoPuò farlo: è il suo schermo. Non dare mai una ricompensa per "aver guardato la cutscene".
Inviare CutsceneEvent con qualsiasi valoreFa qualcosa solo un numero che corrisponde alla sua cutscene attuale, e tutto quello che fa è sbloccarlo prima.
Toccare il trigger da qualsiasi punto della mappaPossibile: ogni dispositivo controlla il proprio personaggio, e la documentazione di Roblox sulla sicurezza cita la falsificazione degli eventi Touched tra le cose che può fare. Vedrà quella cutscene una volta, e non succederà altro.
Muoversi comunque durante la cutsceneNon c'è niente da guadagnare. Il blocco serve a impedire ai giocatori onesti di andarsene a metà cutscene; non è un controllo di sicurezza.
Avviare tramite il remote una cutscene a qualcun altroImpossibile. Solo il server può inviare CutsceneEvent a un giocatore, e l'unica cosa che il dispositivo può rimandare è "questa cutscene è finita".

Se la cutscene porta a qualcosa di reale, per esempio una porta che poi si apre o la comparsa di un boss, fallo fare al server con il suo timer, non quando il dispositivo comunica che la cutscene è finita.

Passo 5: Provala

  1. Piazza tre inquadrature di Intro con la riga per la Command Bar. Dai all'inquadratura 1 la Caption "Welcome to the village", all'inquadratura 2 MoveSeconds 2.5 e Caption "Find the bridge", e lascia l'inquadratura 3 senza attributi.
  2. Premi Play (F5). Compaiono le bande nere, la camera passa all'inquadratura 1 con la sua didascalia, in 2.5 secondi si sposta all'inquadratura 2, poi in 3 secondi all'inquadratura 3 senza didascalia. Poi la camera torna dietro al personaggio e la lista dei giocatori ricompare. Mentre è in corso non puoi camminare.
  3. Ferma il test, premi di nuovo Play e premi Skip mentre la camera si sposta verso l'inquadratura 2. La camera torna subito, e puoi camminare subito.
  4. Entra in BridgeTrigger: parte la cutscene Bridge. Attraversalo di nuovo: non succede nulla.
  5. Scegli Server & Clients nel menu a tendina della modalità di test, imposta 2 client e premi Play. Quando Client 1 entra nel trigger, la cutscene Bridge parte solo per Client 1, e Client 2 può camminare.
  6. Lascia attivo Workspace.StreamingEnabled e sposta un'inquadratura lontano dallo spawn. Quando la camera arriva, l'ambiente deve esserci (probabilmente, ma non con certezza: vedi Streaming).
  7. Per il gamepad, ferma il test, premi Play, apri il Controller Emulator (scheda Emulation, poi Controller) ed entra in BridgeTrigger con il gamepad emulato: Skip deve essere selezionato, quindi A salta la cutscene. Se usi il Device Simulator di Studio (al momento della nostra verifica del 15 ottobre 2026 è una beta: attivala in File, Beta Features, New Device Simulator e riavvia Studio), scegli un telefono, ruotalo in orizzontale e controlla che Skip non finisca sotto il notch della fotocamera e sia facile da premere, e che lo stick e il pulsante di salto siano nascosti durante la cutscene.
  8. Se hai fatto anche il menu principale, premi Play, poi il pulsante Play del menu e lascia che l'intro arrivi alla fine: dopo, la lista dei giocatori deve essere di nuovo sullo schermo.

Tieni la finestra Output aperta (menu Window, poi Output) per tutto il tempo. Quando tutto funziona, questi script non scrivono nulla, quindi qualsiasi avviso o errore rosso di CutsceneService o CutscenePlayer è un problema reale. Vedi Errori comuni.

Come estendere il sistema

Intro solo al primo ingresso del giocatore

La tabella seen vive per un solo server, quindi un giocatore che rientra rivede l'intro. Per mostrarla solo al primo ingresso, salva un flag, per esempio SeenIntro, insieme agli altri dati del giocatore con il modulo PlayerData del tutorial sui DataStore. Lascia INTRO_CUTSCENE com'è e cambia la parte di onCharacterAdded in CutsceneService che gestisce l'intro: aspetta che PlayerData.Get(player) restituisca i dati del giocatore, salta l'intro se data.SeenIntro è true, e imposta data.SeenIntro = true solo quando playOnce(player, INTRO_CUTSCENE) ha restituito true. Non avviare l'intro dal codice che carica i dati: i dati possono caricarsi prima che il personaggio faccia spawn, e senza personaggio play non fa nulla, e il flag verrebbe salvato per un'intro che nessuno ha visto.

Personaggi che recitano nella cutscene

Crea un'animazione con l'Animation Editor di Studio o con un plugin di animazione di terze parti, per esempio Moon Animator, citato nella documentazione di Roblox, e riproducila sul rig di un NPC nell'inquadratura quando la camera ci arriva. Il riferimento di Roblox su Animator dice che le animazioni degli NPC si replicano solo se le carica e le avvia il server, quindi riproducila da uno Script del server se tutti i giocatori devono vedere l'NPC recitare. Se la carichi e la avvii in CutscenePlayer, l'animazione non si replica, e va bene per una cutscene che guarda un solo giocatore. La guida agli script di animazione mostra come riprodurre un'animazione su un NPC da uno Script del server.

Dialoghi

Le didascalie vanno bene per battute brevi che scorrono da sole. Per una conversazione in cui il giocatore risponde e sceglie opzioni, vedi la guida ai dialoghi con gli NPC.

Intro dopo il menu principale

La guida al menu principale disattiva CharacterAutoLoads, quindi nessuno fa spawn finché non preme Play. CutsceneService riproduce l'intro al primo spawn del giocatore, quindi con entrambi i sistemi l'intro parte al primo spawn dopo Play. Il menu riattiva le core GUI quando compare il personaggio, e questo può succedere quando l'intro è già in corso, quindi durante l'intro potrebbe vedersi la lista dei giocatori. CutscenePlayer riattiva solo ciò che ha nascosto lui, quindi non tocca la modifica del menu, e dopo l'intro restano attive. Il trucco con la Command Bar della guida al menu principale per puntare la parte della camera è lo stesso del passo 1.

Sorvolo della mappa a inizio round

Per avviare una cutscene da un altro script del server, per esempio un sorvolo della mappa a inizio round dalla guida al sistema di round, aggiungi in ServerStorage un BindableEvent chiamato PlayCutscene. Alla fine di CutsceneService collega il suo Event alla funzione play, e fai in modo che lo script dei round lo chiami con ogni giocatore e il nome della cutscene. play salta il controllo "una volta per server", quindi il sorvolo parte a ogni round.

Plugin per cutscene

I plugin si possono usare insieme a questa guida. Se un plugin per cutscene scrive il proprio script della camera, controlla che restituisca la camera (CameraType Custom e CameraSubject) e imposti Focus mentre la camera è Scriptable, e lascia al server la decisione su chi vede la cutscene, come in questa guida.

Errori comuni e soluzioni

Apri la finestra Output (menu Window, poi Output) prima di premere Play. La maggior parte dei problemi con le cutscene scrive lì un avviso oppure nasce da un nome che non corrisponde.

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

CutsceneService aspetta una cartella chiamata Cutscenes direttamente in Workspace. Creala come nel passo 1 e controlla l'ortografia e la C maiuscola. Finché non c'è, CutsceneService non crea CutsceneEvent, quindi anche CutscenePlayer resta in attesa.

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

CutscenePlayer aspetta il remote creato da CutsceneService. Controlla che CutsceneService sia uno Script e non un LocalScript, che stia direttamente in ServerScriptService, che non sia disattivato e che nell'Output non ci siano errori o avvisi su Cutscenes provenienti da lui.

CutsceneService: no folder named Intro in Workspace.Cutscenes

Il nome in INTRO_CUTSCENE o nell'attributo Cutscene del trigger non corrisponde a nessuna cartella dentro Workspace.Cutscenes. Maiuscole e minuscole nei nomi contano.

Non parte niente e l'Output è vuoto

Nella cartella non c'è una parte chiamata 1, oppure le sue parti non stanno direttamente lì (per esempio sono dentro un Model). CutsceneService legge le parti 1, 2, 3 in ordine e si ferma al primo numero mancante. E ricorda che ogni cutscene parte una volta per giocatore per server: ferma il test e premi di nuovo Play.

La camera guarda dalla parte sbagliata

La camera guarda nella stessa direzione della faccia frontale della parte inquadratura. Porta la camera di Studio sulla vista giusta ed esegui di nuovo la riga per la Command Bar del passo 1 per quell'inquadratura.

Il trigger non fa nulla

Controlla che la parte trigger stia direttamente dentro Workspace.CutsceneTriggers quando il gioco parte, che CanTouch sia spuntato (altrimenti nell'Output c'è un avviso) e che il suo attributo Cutscene sia una stringa con il nome di una cartella in Workspace.Cutscenes. Riattraversare il trigger non fa nulla, ed è voluto.

Dopo la cutscene la camera resta sull'ultima inquadratura

CutscenePlayer si è fermato con un errore prima di restituire la camera, quindi cerca un suo errore rosso nell'Output. La camera può essere trattenuta anche da un altro script che continua a impostare CameraType su Scriptable, per esempio la camera di un menu ancora collegata.

Falla con RoCode

Se non hai voglia di montarla a mano, RoCode può farla nel place che hai aperto. RoCode è un agente IA indipendente per Roblox Studio, non di Roblox: descrivi la funzione nella sua chat web, e il suo plugin per Studio crea la parte e gli script nel tuo Explorer, quindi non devi copiare codice dalla finestra della chat.

Tu scrivi

Aggiungi una cutscene introduttiva: una cartella Cutscenes con una cartella Intro e le inquadrature da 1 a 3, didascalie dall'attributo Caption, bande nere e un pulsante Skip, parte una volta al primo spawn del giocatore, il server tiene fermo il giocatore e alla fine la camera torna indietro.

RoCode fa
  • Può prima controllare il tuo place con Search Scripts, per esempio per uno script di menu o di camera che imposta già CameraType, così non vanno in conflitto
  • Crea le cartelle e la parte trigger con Create Instance e imposta sulle parti attributi come Caption e MoveSeconds
  • Scrive CutsceneService e CutscenePlayer con Create Script
  • Ha l'istruzione di verificare ogni script che scrive con Check Script, che lo compila in Studio senza eseguirlo, e mette un punto di annullamento prima e dopo ogni gruppo di modifiche

Piazza tu le parti inquadratura, portando la camera di Studio su ogni vista, e poi chiedi gli script. Con il plugin 3.9 o successivo RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.11 o successivo può controllare un personaggio di prova per verificare che il gioco funzioni, ma durante il gioco non fa screenshot, quindi la cutscene la guardi tu. L'ordine in cui costruire un gioco intero è nella pagina come fare un gioco su Roblox con l'IA, sistema per sistema. Come RoCode si collega a Studio.

Domande frequenti

Come faccio a far partire una cutscene all'ingresso nel gioco?

Chiama la cartella delle inquadrature Intro in Workspace.Cutscenes oppure cambia INTRO_CUTSCENE con il nome della tua cartella. CutsceneService la riproduce al primo spawn di ogni giocatore sul server. Per mostrarla solo al primissimo ingresso, salva un flag in un data store e impostalo solo dopo che l'intro è iniziata, come descritto in Come estendere il sistema.

Si può fare una cutscene senza plugin?

Sì. In questa guida ci sono solo parti, attributi e due script, e la riga per la Command Bar mette ogni inquadratura esattamente dove si trova la camera di Studio. Plugin come Moon Animator restano comodi per animare i personaggi che recitano nella cutscene.

Perché la camera non si muove nella cutscene?

Di solito il codice della camera sta in uno Script del server, mentre solo un LocalScript può muovere la camera del giocatore, perché ogni dispositivo ha la sua camera. Un'altra causa comune: CameraType non è Scriptable, e gli script della camera predefiniti di Roblox riportano continuamente la camera al personaggio.

Come impedisco al giocatore di muoversi durante una cutscene?

Ancora il suo HumanoidRootPart sul server mentre è in corso e togli l'ancoraggio dopo, come fa CutsceneService. Una parte ancorata non si muove mai per la fisica. WalkSpeed non viene toccata, quindi non va in conflitto con uno script di corsa o un pass di velocità.

Come aggiungo un pulsante Skip alla cutscene?

Metti un TextButton sulla schermata della cutscene e collega il suo evento Activated, che scatta con un clic, un tap o il pulsante A del gamepad quando il pulsante è selezionato. Lo Skip di CutscenePlayer imposta un flag che il ciclo delle inquadrature controlla a ogni frame, si seleziona da solo per chi usa il gamepad e sta nel suo ScreenGui con i margini predefiniti, così il notch della fotocamera del telefono non lo copre. Lo stick e il pulsante di salto sono nascosti durante la cutscene, quindi non gli stanno accanto.

Perché nella cutscene il mondo è vuoto?

Con l'instance streaming attivo il dispositivo del giocatore ha solo la zona vicina al suo personaggio. Fai chiamare al server player:RequestStreamAroundAsync per ogni inquadratura poco prima che la camera ci arrivi, come fa CutsceneService. Roblox scrive che così la zona sarà probabilmente, ma non sicuramente, caricata, quindi tieni le inquadrature importanti entro il raggio di streaming oppure usa Player:AddReplicationFocus per una zona che deve restare caricata.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.