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
Come funziona una cutscene
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:
- Il server decide che il giocatore deve vedere una cutscene:
Introal primo spawn sul server, oppure un'altra quando tocca una parte trigger. - 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
CutsceneEventsolo a quel giocatore con un id e la lista delle inquadrature. - 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.
- Quando finisce l'ultima inquadratura o il giocatore preme Skip, restituisce la camera al personaggio e invia al server
CutsceneEventcon lo stesso id. - 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.
| Elemento | Dove si trova | Cosa fa |
|---|---|---|
Script CutsceneService | ServerScriptService | Decide chi vede quale cutscene e quando, legge le inquadrature, tiene fermo il giocatore e ricorda chi ha già visto cosa. |
LocalScript CutscenePlayer | StarterPlayer, StarterPlayerScripts | Riproduce la cutscene sullo schermo del giocatore: bande, didascalie, Skip e movimento della camera. Alla fine restituisce la camera. |
RemoteEvent CutsceneEvent | ReplicatedStorage (lo crea CutsceneService) | Porta le inquadrature dal server a un giocatore e, nell'altra direzione, il messaggio "la cutscene è finita". |
Folder Cutscenes | Workspace | Una cartella per cutscene, per esempio Intro, con le parti inquadratura 1, 2, 3. |
Folder CutsceneTriggers | Workspace (facoltativa) | Parti che avviano una cutscene quando il giocatore le tocca. |
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.
- Nell'Explorer passa il mouse su Workspace, clicca sul pulsante + e inserisci una Folder chiamata
Cutscenes. Dentro inserisci una Folder chiamataIntro. Maiuscole e minuscole nei nomi contano. - Porta la camera di Studio sulla prima vista che vuoi, come se componessi l'inquadratura per una foto.
- Inserisci una Part in Intro e rinominala
1. - Apri la Command Bar (nella scheda Script oppure da Window, poi Script) ed esegui
workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. In modalità modificaCurrentCameraè 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. - 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.
- Ripeti per le viste successive, chiamando le parti
2,3e 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.
| Attributo | Tipo | Predefinito | Cosa fa |
|---|---|---|---|
MoveSeconds | number | 3 | Quanti 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. |
HoldSeconds | number | 1 | Quanti secondi la camera resta su questa inquadratura dopo esserci arrivata. |
Caption | string | nessuno | Testo 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.
-- 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.
| Impostazione | Valore qui | Cosa 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_SECONDS | 3 | Quanto dura uno spostamento se l'inquadratura non ha l'attributo MoveSeconds. |
DEFAULT_HOLD_SECONDS | 1 | Quanto la camera resta su un'inquadratura se non ha l'attributo HoldSeconds. |
MAX_SHOTS | 30 | Il numero di inquadratura più alto che CutsceneService cerca in una cutscene. |
Cosa fa il resto dello script, in ordine:
- Legge le inquadrature sul server.
readShotsraccoglie 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.
playnon 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.delaysblocca 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
seenricorda 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.playOncerestituisce 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
- Nell'Explorer espandi StarterPlayer, passa il mouse su StarterPlayerScripts e inserisci un LocalScript chiamato
CutscenePlayer. - Sostituisci il suo contenuto con il codice qui sotto.
-- 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.
| Parte | Cosa fa |
|---|---|
ScreenGui Cutscene | Due 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 CutsceneControls | Contiene 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_GUIS | Nasconde 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. |
TouchControlsEnabled | Su 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. |
updateCamera | Gira 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. |
waitOrSkip | Aspetta il tempo dello spostamento e della pausa dell'inquadratura, controllando il flag di Skip a ogni frame. |
play | Rende 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 Skip | Activated 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.
- In Workspace, Cutscenes inserisci una Folder chiamata
Bridgee piazza le sue inquadrature come nel passo 1, con i nomi1e2. Nella riga per la Command Bar scriviBridgeinvece diIntro. - Passa il mouse su Workspace e inserisci una Folder chiamata
CutsceneTriggers. - 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. - Aggiungile un attributo
Cutscenedi tipo string con valoreBridge: 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.
| EASING_STYLE | Come si percepisce lo spostamento |
|---|---|
Enum.EasingStyle.Sine (qui) | La velocità segue una sinusoide, partenza morbida e arresto morbido. |
Enum.EasingStyle.Quad | Come Sine, ma con una curva un po' più netta. |
Enum.EasingStyle.Linear | Velocità 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.
| Tutorial | Problema | Questa 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'altro | Focus 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 camera | Il 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 LocalScript | Niente 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 client | Con 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.
| Il cheater tenta di | Risultato |
|---|---|
| Saltare la cutscene o non riprodurla affatto | Può farlo: è il suo schermo. Non dare mai una ricompensa per "aver guardato la cutscene". |
Inviare CutsceneEvent con qualsiasi valore | Fa qualcosa solo un numero che corrisponde alla sua cutscene attuale, e tutto quello che fa è sbloccarlo prima. |
| Toccare il trigger da qualsiasi punto della mappa | Possibile: 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 cutscene | Non 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 altro | Impossibile. 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
- Piazza tre inquadrature di Intro con la riga per la Command Bar. Dai all'inquadratura 1 la
Caption"Welcome to the village", all'inquadratura 2MoveSeconds2.5 eCaption"Find the bridge", e lascia l'inquadratura 3 senza attributi. - 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.
- 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.
- Entra in BridgeTrigger: parte la cutscene Bridge. Attraversalo di nuovo: non succede nulla.
- 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.
- Lascia attivo
Workspace.StreamingEnablede sposta un'inquadratura lontano dallo spawn. Quando la camera arriva, l'ambiente deve esserci (probabilmente, ma non con certezza: vedi Streaming). - 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.
- 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.
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.
- 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
- Roblox Creator Docs: Customize the camera (in inglese). una Camera per ogni client, Scriptable, CFrame e Focus
- Roblox Engine API: Camera (in inglese). CameraType, CameraSubject, Focus a ogni frame e Interpolate deprecato
- Roblox Creator Docs: Control the user's camera (in inglese). BindToRenderStep un passo di priorità dopo la camera
- Roblox Engine API: TweenService:GetValue (in inglese). alpha con easing, limitata tra 0 e 1
- Roblox Engine API: ScreenGui.ScreenInsets (in inglese). perché None solo per contenuti che non si premono
- Roblox Creator Docs: Instance streaming (in inglese). attivo di default nei place nuovi, e replication focus
- Roblox Creator Docs: Streaming techniques (in inglese). precaricare una zona prima di inviare un evento
- Roblox Engine API: Player:RequestStreamAroundAsync (in inglese). richiesta temporanea senza garanzia
- Roblox Creator Docs: Remote events and callbacks (in inglese). coda dei messaggi e quali tabelle si possono inviare
- Roblox Creator Docs: Network ownership, movement validation, and physics (in inglese). cosa può fare il client con il proprio personaggio, compresa la falsificazione degli eventi Touched
- Roblox Engine API: Animator:LoadAnimation (in inglese). quali animazioni si replicano
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.