Pe scurt
Pune part-uri invizibile ancorate cu numele 1, 2, 3 într-un folder din Workspace.Cutscenes, fiecare cu fața spre unde trebuie să privească camera. Un Script în ServerScriptService le citește CFrame-urile, ține jucătorul pe loc și îi trimite cadrele acelui jucător printr-un RemoteEvent. Un LocalScript în StarterPlayerScripts setează workspace.CurrentCamera.CameraType la Scriptable, la fiecare cadru mișcă camera de la un plan la altul (netezind prin TweenService:GetValue), apoi readuce CameraType la Custom și CameraSubject la Humanoid-ul jucătorului.
- Camera o poate controla doar dispozitivul jucătorului, așa că codul camerei e un LocalScript. Serverul doar decide cine ce cutscene vede și când.
- Când camera e Scriptable, Roblox nu mai actualizează
Camera.Focus. Referința spune să actualizezi Focus la fiecare cadru, altfel lumina dinamică departe de vechiul focus poate să nu se randeze. Camera:Interpolatee învechit. Referința Roblox spune să animezi camera prin TweenService.
Pe această pagină
Cum funcționează un cutscene
Fiecare dispozitiv al unui jucător are propriul obiect Camera, în workspace.CurrentCamera, așa că ce vede jucătorul poate mișca doar un LocalScript. Să decidă cine ce cutscene vede și când e treaba serverului. Ghidul împarte munca exact așa. Un cutscene decurge așa:
- Serverul decide că jucătorul trebuie să vadă un cutscene:
Introla prima apariție pe server sau altul, când atinge un part-trigger. - CutsceneService citește CFrame-urile și setările part-urilor-cadru, îi cere lui Roblox să încarce pentru acel jucător zona primului cadru, ancorează HumanoidRootPart-ul jucătorului ca să stea pe loc și trimite
CutsceneEventdoar acelui jucător, cu un id și lista de cadre. - CutscenePlayer de pe dispozitivul jucătorului arată benzile negre și butonul Skip, ascunde lista de jucători, rucsacul, bara de viață și controalele tactile, face camera Scriptable și o mișcă la fiecare cadru.
- Când se termină ultimul cadru sau jucătorul apasă Skip, readuce camera la personaj și îi trimite serverului
CutsceneEventcu același id. - Serverul scoate ancorarea jucătorului. Dacă mesajul nu a venit niciodată, o scoate oricum după ce trece lungimea cutscene-ului plus 2 secunde. Cronometrul pornește când serverul trimite cutscene-ul, iar la o intrare lentă dispozitivul poate începe introul cu câteva secunde mai târziu, pentru că un LocalScript din afara ReplicatedFirst nu pornește până nu s-a încărcat jocul. Atunci jucătorul se poate mișca din nou înainte ca introul să se termine pe ecranul lui.
| Element | Unde se află | Ce face |
|---|---|---|
Script CutsceneService | ServerScriptService | Decide cine ce cutscene vede și când, citește cadrele, ține jucătorul pe loc și ține minte cine ce a văzut deja. |
LocalScript CutscenePlayer | StarterPlayer, StarterPlayerScripts | Redă cutscene-ul pe ecranul jucătorului: benzi, subtitrări, Skip și mișcarea camerei. La final readuce camera. |
RemoteEvent CutsceneEvent | ReplicatedStorage (îl creează CutsceneService) | Duce cadrele de la server la un jucător și înapoi mesajul "cutscene-ul s-a terminat". |
Folder Cutscenes | Workspace | Câte un folder pe cutscene, de exemplu Intro, cu part-urile-cadru 1, 2, 3. |
Folder CutsceneTriggers | Workspace (opțional) | Part-uri care pornesc un cutscene când jucătorul le atinge. |
Workspace
Cutscenes Folder new
Intro Folder new
1 Part new
2 Part new
3 Part new
Bridge Folder new
1 Part new
2 Part new
CutsceneTriggers Folder new
BridgeTrigger Part new
ServerScriptService
CutsceneService Script new
StarterPlayer
StarterPlayerScripts
CutscenePlayer LocalScript new
Pasul 1: așază cadrele camerei
Fiecare cadru e un part invizibil. Camera ia poziția part-ului și se uită în aceeași direcție ca fața lui din față, așa că a pune un cadru înseamnă a pune camera.
- În Explorer treci cu mouse-ul peste Workspace, apasă butonul + și inserează un Folder numit
Cutscenes. În el inserează un Folder numitIntro. Majusculele din nume contează. - Du camera Studio la prima vedere dorită, ca și cum ai încadra o fotografie.
- Inserează un Part în Intro și redenumește-l în
1. - Deschide Command Bar (în fila Script sau prin Window, apoi Script) și rulează
workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. În modul de editare,CurrentCamerae vederea prin care te uiți, așa că part-ul ajunge exact în acest cadru. Parantezele și ghilimelele sunt necesare pentru că un nume care începe cu o cifră nu se poate scrie după punct. - În Properties-ul part-ului bifează Anchored, debifează CanCollide, CanTouch și CanQuery și setează Transparency la 1. Anchored îl împiedică să cadă prin hartă; restul îl împiedică să încurce jucătorii, să declanșeze evenimente de atingere și să blocheze raycast-urile.
- Repetă pentru vederile următoare, numind part-urile
2,3și așa mai departe și schimbând numărul din rândul pentru Command Bar. CutsceneService redă cadrele în ordinea numerelor și se oprește la primul număr lipsă, așa că o gaură în numerotare taie cutscene-ul mai devreme.
Ca să schimbi mai târziu un cadru, du camera la noua vedere și rulează același rând cu numărul acelui cadru. Cu Transparency 1, part-urile sunt invizibile și în Studio, așa că selectează-le din Explorer când ai nevoie de ele.
Fiecare cadru mai poate avea trei atribute opționale. Ca să adaugi un atribut, selectează part-ul, derulează fereastra Properties până la secțiunea Attributes, apasă +, scrie numele, alege tipul și apasă Save.
| Atribut | Tip | Implicit | Ce face |
|---|---|---|---|
MoveSeconds | number | 3 | Câte secunde zboară camera de la cadrul anterior la acesta. 0 face o tăietură bruscă. Cadrul 1 e mereu o tăietură, așa că pentru el atributul nu are efect. |
HoldSeconds | number | 1 | Câte secunde stă camera pe acest cadru după ce ajunge. |
Caption | string | nimic | Textul de pe banda de jos din momentul în care camera începe să zboare spre acest cadru. Un cadru fără Caption golește textul. |
Un număr mai mic decât 0 sau mai mare decât 60, precum și un atribut de tip greșit, se înlocuiesc cu valoarea implicită.
Pasul 2: adaugă scriptul de server
Treci cu mouse-ul peste ServerScriptService, inserează un Script numit CutsceneService și lipește în el codul de mai jos. Setările de sus sunt rândurile pe care le poți schimba.
-- Script în ServerScriptService cu numele CutsceneService.
-- Decide cine ce cutscene vede și când. Citește cadrele camerei din part-urile numerotate
-- din Workspace.Cutscenes, ține jucătorul pe loc și îi spune dispozitivului
-- acelui jucător să redea cadrele. Camera însăși poate fi mișcată doar pe dispozitiv.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Setări
local INTRO_CUTSCENE = "Intro" -- rulează o dată la prima apariție a jucătorului; "" ca să o dezactivezi
local DEFAULT_MOVE_SECONDS = 3 -- timpul de zbor spre un cadru, dacă nu are MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- timpul pe un cadru, dacă nu are HoldSeconds
local MAX_SHOTS = 30
local cutscenes = workspace:WaitForChild("Cutscenes")
local triggers = workspace:FindFirstChild("CutsceneTriggers")
-- Scriptul acesta creează singur CutsceneEvent, așa că nu-l adăuga manual
local cutsceneEvent = Instance.new("RemoteEvent")
cutsceneEvent.Name = "CutsceneEvent"
cutsceneEvent.Parent = ReplicatedStorage
type Shot = { cframe: CFrame, move: number, hold: number, caption: string }
local seen: { [Player]: { [string]: boolean } } = {}
local playing: { [Player]: number } = {} -- id-ul cutscene-ului pe care îl urmărește jucătorul
local lastId = 0
local function secondsAttribute(part: Instance, name: string, default: number): number
local value = part:GetAttribute(name)
if typeof(value) == "number" and value >= 0 and value <= 60 then
return value
end
return default
end
-- Cadrele sunt part-urile 1, 2, 3 ... din folderul cu numele cutscene-ului
local function readShots(name: string): { Shot }
local shots: { Shot } = {}
local folder = cutscenes:FindFirstChild(name)
if not folder then
warn(`CutsceneService: no folder named {name} in Workspace.Cutscenes`)
return shots
end
for index = 1, MAX_SHOTS do
local part = folder:FindFirstChild(tostring(index))
if not (part and part:IsA("BasePart")) then
break
end
local caption = part:GetAttribute("Caption")
table.insert(shots, {
cframe = part.CFrame,
-- primul cadru e o tăietură, așa că camera sare direct în el
move = if index == 1 then 0 else secondsAttribute(part, "MoveSeconds", DEFAULT_MOVE_SECONDS),
hold = secondsAttribute(part, "HoldSeconds", DEFAULT_HOLD_SECONDS),
caption = if typeof(caption) == "string" then caption else "",
})
end
return shots
end
local function setFrozen(player: Player, frozen: boolean)
local character = player.Character
local rootPart = character and character:FindFirstChild("HumanoidRootPart")
if rootPart and rootPart:IsA("BasePart") then
rootPart.Anchored = frozen
end
end
local function finish(player: Player, id: number)
if playing[player] ~= id then
return -- acest cutscene s-a terminat deja
end
playing[player] = nil
setFrozen(player, false)
end
local function play(player: Player, name: string): boolean
if playing[player] then
return false -- un cutscene pe rând
end
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 then
return false
end
local shots = readShots(name)
if #shots == 0 then
return false
end
lastId += 1
local id = lastId
playing[player] = id
-- Cu instance streaming activ, dispozitivul jucătorului poate să nu aibă zona
-- spre care se uită cadrul, iar cererea încarcă zona doar temporar. Încărcăm
-- acum zona primului cadru (așteptăm până la 2 secunde), iar zona fiecărui cadru următor
-- cu 2 secunde înainte să zboare camera spre el.
local function request(position: Vector3)
pcall(function()
player:RequestStreamAroundAsync(position, 2)
end)
end
request(shots[1].cframe.Position)
if playing[player] ~= id or player.Parent ~= Players then
return false -- jucătorul a ieșit cât se încărca zona
end
setFrozen(player, true)
cutsceneEvent:FireClient(player, id, shots)
local startsAt = 0 -- secunde de acum până la începutul zborului spre acest cadru
for index, shot in shots do
if index > 1 then
task.delay(math.max(startsAt - 2, 0), function()
if playing[player] == id then
request(shot.cframe.Position)
end
end)
end
startsAt += shot.move + shot.hold
end
-- Plasă de siguranță: dezghețăm jucătorul chiar dacă dispozitivul lui nu a răspuns niciodată
task.delay(startsAt + 2, finish, player, id)
return true
end
-- Returnează true doar dacă cutscene-ul a pornit pentru acest jucător
local function playOnce(player: Player, name: string): boolean
local playerSeen = seen[player]
if not playerSeen or playerSeen[name] then
return false
end
if play(player, name) then
playerSeen[name] = true
return true
end
return false
end
-- Dispozitivul jucătorului raportează că cutscene-ul s-a terminat sau a fost sărit
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
if typeof(id) == "number" then
finish(player, id)
end
end)
-- Part-uri declanșatoare: atingerea pornește cutscene-ul din atributul lor Cutscene
if triggers then
for _, trigger in triggers:GetChildren() do
if not trigger:IsA("BasePart") then
continue
end
if not trigger.CanTouch then
-- Conectarea Touched la un part cu CanTouch dezactivat dă eroare, așa că doar avertizăm
warn(`CutsceneService: tick CanTouch on {trigger:GetFullName()} so it can start a cutscene`)
continue
end
trigger.Touched:Connect(function(otherPart: BasePart)
local name = trigger:GetAttribute("Cutscene")
local character = otherPart:FindFirstAncestorOfClass("Model")
local player = character and Players:GetPlayerFromCharacter(character)
if player and typeof(name) == "string" then
playOnce(player, name)
end
end)
end
end
local function onCharacterAdded(player: Player, character: Model)
character:WaitForChild("HumanoidRootPart", 10)
if playing[player] then
setFrozen(player, true) -- respawn în timpul cutscene-ului, ținem pe loc și noul personaj
elseif INTRO_CUTSCENE ~= "" then
playOnce(player, INTRO_CUTSCENE)
end
end
local function onPlayerAdded(player: Player)
if seen[player] then
return -- deja configurat
end
seen[player] = {}
player.CharacterAdded:Connect(function(character: Model)
onCharacterAdded(player, character)
end)
local character = player.Character
if character then
task.spawn(onCharacterAdded, player, character)
end
end
Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- toți cei care au intrat cât scriptul aștepta Cutscenes
onPlayerAdded(player)
end
Players.PlayerRemoving:Connect(function(player: Player)
seen[player] = nil
playing[player] = nil
end)
CutsceneService creează singur RemoteEvent-ul CutsceneEvent imediat ce apare Workspace.Cutscenes, așa că nu trebuie să inserezi nimic manual în ReplicatedStorage. Dacă ai făcut deja un RemoteEvent cu acest nume, șterge-l: LocalScript-ul îl poate găsi pe al tău, pe care nu îl ascultă nimeni pe server.
| Setare | Valoarea aici | Ce schimbă |
|---|---|---|
INTRO_CUTSCENE | "Intro" | Folderul din Workspace.Cutscenes care rulează la prima apariție a jucătorului pe server. Pune "" ca să nu existe intro. |
DEFAULT_MOVE_SECONDS | 3 | Cât durează zborul dacă un cadru nu are atributul MoveSeconds. |
DEFAULT_HOLD_SECONDS | 1 | Cât stă camera pe un cadru dacă acesta nu are atributul HoldSeconds. |
MAX_SHOTS | 30 | Cel mai mare număr de cadru pe care CutsceneService îl caută într-un cutscene. |
Ce face restul scriptului, în ordine:
- Citește cadrele pe server.
readShotsadună CFrame-ul și atributele fiecărui part numerotat într-o listă. Dispozitivul jucătorului primește lista, așa că nu are nevoie de part-uri. - Un cutscene pe rând.
playnu face nimic cât timp jucătorul urmărește deja un cutscene sau dacă personajul lui nu are Humanoid ori e mort. - Fiecare cutscene are propriul id. Dispozitivul trimite id-ul înapoi când cutscene-ul se termină sau e sărit, iar jucătorul e dezghețat doar de id-ul care se potrivește, așa că un mesaj întârziat de la un cutscene anterior nu poate termina unul nou.
- Ține jucătorul pe loc ancorându-i HumanoidRootPart-ul și ancorează noul personaj dacă jucătorul face respawn în mijlocul cutscene-ului. Referința Roblox spune că un part ancorat nu își schimbă niciodată poziția din cauza gravitației, coliziunilor sau altei fizici. WalkSpeed-ul nu e atins, așa că nu intră în conflict cu un script de sprint sau un pass de viteză. La final scriptul scoate ancorarea de pe root part chiar dacă l-a ancorat alt script, așa că nu ancora personajele în altă parte cât timp poate rula un cutscene.
- Plasă de siguranță.
task.delaydezgheață jucătorul după lungimea completă a cutscene-ului plus 2 secunde, chiar dacă dispozitivul lui nu a răspuns niciodată. - Fiecare cutscene o dată pe server. Tabelul
seenține minte, pentru fiecare jucător, ce cutscene-uri au început deja, așa că introul nu se repetă la respawn, iar un cutscene de la un trigger rulează o singură dată.playOncereturnează true doar dacă cutscene-ul chiar a pornit. - Configurează fiecare jucător. Bucla peste
Players:GetPlayers()de la final îi prinde pe toți cei care au intrat cât scriptul aștepta folderul Cutscenes.
Cadrele pleacă la jucător într-un singur apel FireClient, ca o listă de tabele mici. Pagina Roblox despre remote events spune să nu trimiți un tabel în care sunt amestecate chei numerice și chei text; în lista asta sunt doar chei numerice, iar în fiecare cadru dinăuntru doar chei text, forma recomandată acolo.
Pasul 3: adaugă LocalScript-ul care îl redă
- În Explorer deschide StarterPlayer, treci cu mouse-ul peste StarterPlayerScripts și inserează un LocalScript numit
CutscenePlayer. - Înlocuiește-i conținutul cu codul de mai jos.
-- LocalScript în StarterPlayer > StarterPlayerScripts cu numele CutscenePlayer.
-- Redă cutscene-ul trimis de server: benzi negre, subtitrări, butonul Skip și
-- camera care zboară de la un cadru la altul. Apoi îi dă camera înapoi jucătorului.
local GuiService = game:GetService("GuiService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local StarterGui = game:GetService("StarterGui")
local TweenService = game:GetService("TweenService")
local UserInputService = game:GetService("UserInputService")
local cutsceneEvent = ReplicatedStorage:WaitForChild("CutsceneEvent") :: RemoteEvent
local player = Players.LocalPlayer
local camera = workspace.CurrentCamera
local BAR_HEIGHT = 0.12 -- fiecare bandă neagră, ca fracție din înălțimea ecranului
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- câți studs în fața camerei să deseneze Roblox cu cel mai mare detaliu
local HIDDEN_CORE_GUIS = { Enum.CoreGuiType.PlayerList, Enum.CoreGuiType.Backpack, Enum.CoreGuiType.Health }
local REGULAR = Font.fromEnum(Enum.Font.BuilderSans)
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)
type Shot = { cframe: CFrame, move: number, hold: number, caption: string }
-- Ecranul cutscene-ului: două benzi negre și o subtitrare, de la margine la margine. Roblox recomandă
-- ScreenInsets None doar pentru ce nu apasă nimeni, așa că Skip de mai jos are propriul ScreenGui.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- pe tot ecranul
gui.DisplayOrder = 10
gui.Enabled = false
local topBar = Instance.new("Frame")
topBar.Size = UDim2.fromScale(1, BAR_HEIGHT)
topBar.BackgroundColor3 = Color3.new(0, 0, 0)
topBar.BorderSizePixel = 0
topBar.Parent = gui
local bottomBar = topBar:Clone()
bottomBar.Position = UDim2.fromScale(0, 1 - BAR_HEIGHT)
bottomBar.Parent = gui
local caption = Instance.new("TextLabel")
caption.Size = UDim2.fromScale(0.7, 0.5)
caption.Position = UDim2.fromScale(0.15, 0.25)
caption.BackgroundTransparency = 1
caption.TextColor3 = Color3.new(1, 1, 1)
caption.TextScaled = true
caption.FontFace = REGULAR
caption.Text = ""
caption.Parent = bottomBar
-- Butonul Skip are marginile implicite, așa că decupajul camerei nu îl acoperă
local controls = Instance.new("ScreenGui")
controls.Name = "CutsceneControls"
controls.ResetOnSpawn = false
controls.DisplayOrder = 11
controls.Enabled = false
local skipButton = Instance.new("TextButton")
skipButton.AnchorPoint = Vector2.new(1, 0.5)
skipButton.Size = UDim2.fromScale(0.1, BAR_HEIGHT * 0.5)
skipButton.Position = UDim2.new(1, -16, 1 - BAR_HEIGHT / 2, 0) -- pe banda de jos, în dreapta
skipButton.BackgroundColor3 = Color3.fromRGB(60, 60, 60)
skipButton.TextColor3 = Color3.new(1, 1, 1)
skipButton.TextScaled = true
skipButton.FontFace = BOLD
skipButton.Text = "Skip"
skipButton.Parent = controls
-- Skip rămâne destul de mare cât să-l nimerești pe un telefon mic
local skipMinSize = Instance.new("UISizeConstraint")
skipMinSize.MinSize = Vector2.new(64, 32)
skipMinSize.Parent = skipButton
local playerGui = player:WaitForChild("PlayerGui")
gui.Parent = playerGui
controls.Parent = playerGui
-- Zborul curent: de la un CFrame de cameră la următorul, într-un număr dat de secunde
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false
-- Rulează la fiecare cadru în timpul cutscene-ului. Focus-ul unei camere Scriptable nu urmărește
-- nimic singur, așa că îl setăm tot aici.
local function updateCamera()
if camera.CameraType ~= Enum.CameraType.Scriptable then
camera.CameraType = Enum.CameraType.Scriptable -- ceva l-a resetat, de exemplu un respawn
end
local alpha = if moveSeconds > 0 then (os.clock() - moveStart) / moveSeconds else 1
local eased = TweenService:GetValue(alpha, EASING_STYLE, Enum.EasingDirection.InOut)
camera.CFrame = moveFrom:Lerp(moveTo, eased)
camera.Focus = camera.CFrame * CFrame.new(0, 0, -FOCUS_DISTANCE)
end
local function waitOrSkip(seconds: number)
local endTime = os.clock() + seconds
while os.clock() < endTime and not skipRequested do
task.wait()
end
end
local function play(id: number, shots: { Shot })
if busy then
-- Unul rulează deja, așa că lăsăm serverul să dezghețe imediat jucătorul pentru acesta
cutsceneEvent:FireServer(id)
return
end
busy = true
skipRequested = false
-- Ascundem lista de jucători, rucsacul și bara de viață, ținând minte ce era vizibil
local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
for _, coreGui in HIDDEN_CORE_GUIS do
wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
StarterGui:SetCoreGuiEnabled(coreGui, false)
end
-- Pe telefoane ascundem joystick-ul și butonul de săritură din colțurile de jos
local touchControlsWere = GuiService.TouchControlsEnabled
GuiService.TouchControlsEnabled = false
gui.Enabled = true
controls.Enabled = true
-- Un gamepad poate apăsa doar butonul selectat, așa că pentru jucătorii cu gamepad selectăm Skip
if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
GuiService.SelectedObject = skipButton
end
camera = workspace.CurrentCamera
camera.CameraType = Enum.CameraType.Scriptable
moveTo = camera.CFrame
-- Cu un pas după propria actualizare a camerei Roblox, ca în tutorialul Roblox despre cameră
RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)
for _, shot in shots do
moveFrom = camera.CFrame -- fiecare zbor pornește de unde e camera acum
moveTo = shot.cframe
moveStart = os.clock()
moveSeconds = shot.move
caption.Text = shot.caption
waitOrSkip(shot.move + shot.hold)
if skipRequested then
break
end
end
-- Îi dăm camera înapoi personajului jucătorului
RunService:UnbindFromRenderStep("Cutscene")
camera.CameraType = Enum.CameraType.Custom
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if humanoid then
camera.CameraSubject = humanoid
end
if GuiService.SelectedObject == skipButton then
GuiService.SelectedObject = nil
end
gui.Enabled = false
controls.Enabled = false
caption.Text = ""
-- Reactivăm doar ce a dezactivat acest cutscene, restul nu-l atingem
for coreGui, enabled in wasEnabled do
if enabled then
StarterGui:SetCoreGuiEnabled(coreGui, true)
end
end
if touchControlsWere then
GuiService.TouchControlsEnabled = true
end
cutsceneEvent:FireServer(id) -- serverul dezgheață imediat jucătorul
busy = false
end
skipButton.Activated:Connect(function()
skipRequested = true
end)
cutsceneEvent.OnClientEvent:Connect(function(id: number, shots: { Shot })
play(id, shots)
end)
Un LocalScript din StarterPlayerScripts se copiază la jucător o singură dată, la intrare, și continuă să ruleze după respawn-ul personajului. De aceea ambele ScreenGui au ResetOnSpawn dezactivat: dacă îl activezi, Roblox le șterge la primul respawn, iar scriptul acesta nu le mai creează din nou. Mesajele remote-ului sosite înainte ca scriptul să se conecteze la OnClientEvent intră la coadă și sunt livrate după conectare, așa că un jucător care a apărut repede tot vede introul.
| Parte | Ce face |
|---|---|
ScreenGui Cutscene | Două benzi negre, fiecare de 12% din înălțimea ecranului (BAR_HEIGHT), și subtitrarea pe banda de jos. ScreenInsets None întinde benzile până la marginile ecranului, iar DisplayOrder 10 le desenează peste ScreenGui-urile cu DisplayOrder mai mic. |
ScreenGui CutsceneControls | Conține doar butonul Skip, în dreapta pe banda de jos, cu un UISizeConstraint care îl ține de cel puțin 64 pe 32 de pixeli, ca să fie ușor de nimerit pe telefon. Are ScreenInsets implicit, iar conținutul nu intră sub butoanele barei de sus Roblox și sub decupajele camerei. Roblox recomandă None doar pentru conținut pe care nu ai ce apăsa, așa că Skip nu poate sta în ScreenGui-ul cu benzile. |
HIDDEN_CORE_GUIS | Ascunde lista de jucători, rucsacul și bara de viață prin SetCoreGuiEnabled, după ce a reținut prin GetCoreGuiEnabled care erau activate, iar la final le reactivează doar pe cele pe care le-a dezactivat el. Dacă jocul ascunde rucsacul în altă parte, rămâne ascuns, iar un script care le activează în timpul cutscene-ului, de exemplu meniul principal, nu e anulat. |
TouchControlsEnabled | Pe telefoane și tablete, play setează GuiService.TouchControlsEnabled la false pe durata cutscene-ului. Asta ascunde joystick-ul și butonul de săritură din colțurile de jos, același loc ca Skip, iar la final revin dacă erau activate. |
updateCamera | Rulează la fiecare cadru cât merge cutscene-ul. Calculează ce parte din zborul curent s-a parcurs, o netezește prin TweenService:GetValue, pune camera între două cadre prin CFrame:Lerp și setează Focus la 30 de studs în fața camerei. |
waitOrSkip | Așteaptă timpul de zbor și pauza cadrului, verificând la fiecare cadru flagul Skip. |
play | Face camera Scriptable, redă cadrele în ordine, apoi readuce camera (CameraType Custom, CameraSubject e Humanoid-ul), reactivează core GUI-ul și controalele tactile și îi trimite serverului id-ul cutscene-ului. Dacă un al doilea cutscene vine cât primul încă rulează, îi trimite imediat id-ul înapoi, ca serverul să nu țină jucătorul pe loc pentru un cutscene pe care dispozitivul acesta nu l-a arătat. |
| Butonul Skip | Activated se declanșează la un clic de mouse, o atingere sau butonul A de pe gamepad când butonul e selectat. Pentru un jucător al cărui input principal e gamepad-ul, play selectează Skip la începutul cutscene-ului și scoate selecția la final. |
Schimbă BAR_HEIGHT ca să faci benzile mai subțiri sau mai groase și EASING_STYLE ca să schimbi senzația zborurilor (vezi Ce face corect codul camerei). Subtitrarea și butonul Skip au TextScaled activat, așa că textul crește și scade odată cu ecranul.
Pasul 4: un cutscene la atingerea unui part
Introul rulează singur. Pentru un cutscene într-un anumit loc de pe hartă, de exemplu când jucătorul ajunge prima dată la pod, adaugă un al doilea cutscene și un part-trigger.
- În Workspace, Cutscenes inserează un Folder numit
Bridgeși așază-i cadrele ca la pasul 1, cu numele1și2. În rândul pentru Command Bar scrieBridgeîn loc deIntro. - Treci cu mouse-ul peste Workspace și inserează un Folder numit
CutsceneTriggers. - Inserează în el un Part numit
BridgeTrigger. Fă-l destul de mare cât jucătorii să nu poată trece pe lângă el fără să-l atingă, de exemplu o placă înaltă și lată de-a curmezișul drumului. Bifează Anchored, debifează CanCollide și CanQuery, lasă CanTouch bifat și setează Transparency la 1. CanQuery dezactivat împiedică placa invizibilă să blocheze raycast-urile, de exemplu împușcăturile din ghidul despre arme. Evenimentele de atingere sunt controlate de CanTouch, nu de CanQuery, așa că triggerul funcționează în continuare. - Adaugă-i un atribut
Cutscenede tip string și dă-i valoareaBridge: numele folderului care trebuie redat.
CutsceneService conectează Touched la fiecare part aflat direct în CutsceneTriggers la pornirea serverului, așa că adaugă triggerele în Studio, nu dintr-un script în timpul jocului. Un trigger cu CanTouch dezactivat e sărit cu un avertisment în Output, pentru că Roblox dă eroare când un script conectează Touched la un astfel de part.
Cât timp personajul trece prin part, Touched se declanșează de multe ori la rând. Tabelul seen și regula "un cutscene pe rând" transformă asta într-un singur cutscene pe jucător pe server. Un jucător care atinge triggerul în timpul altui cutscene e ignorat, iar triggerul rămâne pregătit pentru el.
Nu pune triggere pe drumuri. HumanoidRootPart-ul unui jucător așezat e sudat de scaun, iar când un part dintr-un grup sudat e ancorat, Roblox le ancorează și pe celelalte. Așa că un jucător care intră cu vehiculul într-un trigger ține pe loc tot vehiculul, cu pasageri cu tot, până se termină cutscene-ul.
Ce face corect codul camerei
Scriptable, apoi înapoi la Custom
Scripturile de cameră Roblox nu mișcă și nu actualizează camera cât timp CameraType e Scriptable, iar tocmai asta îi permite lui CutscenePlayer să o poziționeze. La final readuce CameraType la Custom și face Humanoid-ul jucătorului CameraSubject, pe care scripturile de cameră Roblox îl urmăresc implicit. Asta se execută și după Skip, așa că jucătorul nu rămâne niciodată uitându-se la ultimul cadru.
Două verificări mici țin cutscene-ul la comandă cât rulează. Dacă ceva setează CameraType la altă valoare în mijlocul cutscene-ului, funcția care rulează la fiecare cadru pune la loc Scriptable la cadrul următor. Iar workspace.CurrentCamera scriptul îl citește din nou la începutul fiecărui cutscene, pentru că Roblox creează o Camera nouă dacă cea curentă e vreodată ștearsă.
Focus, la fiecare cadru
Camera.Focus îi spune motorului cărei zone să-i dea prioritate în munca precum iluminarea. Scripturile de cameră Roblox îl țin pe CameraSubject, dar nu și când camera e Scriptable, iar referința Roblox spune ca în acest caz să-l actualizezi la fiecare cadru: lumina dinamică de la obiecte precum PointLight poate să nu se randeze departe de focus. CutscenePlayer îl pune la 30 de studs în fața camerei (FOCUS_DISTANCE). Mărește numărul dacă cadrele tale se uită la ceva mai îndepărtat.
Funcția rulează prin RunService:BindToRenderStep, la fiecare cadru înainte de randare, cu un pas de prioritate după propria actualizare a camerei Roblox (Enum.RenderPriority.Camera.Value + 1). Această prioritate o folosește tutorialul Roblox despre cameră, așa că cutscene-ul poziționează camera după ce a rulat propriul cod de cameră al Roblox.
Netezire prin TweenService:GetValue
Un tween pe camera.CFrame ar mișca camera, dar Focus tot trebuie setat la fiecare cadru, așa că CutscenePlayer mișcă singur camera în aceeași funcție. Pentru fiecare zbor calculează ce fracție din timp a trecut (de la 0 la 1), o trece prin TweenService:GetValue cu un stil și o direcție de netezire și pune camera la acea fracție din drumul dintre două cadre prin CFrame:Lerp, care mută poziția în linie dreaptă și rotește lin. GetValue limitează intrarea între 0 și 1, așa că camera se oprește exact pe cadru când se termină timpul de zbor.
| EASING_STYLE | Cum se simte zborul |
|---|---|
Enum.EasingStyle.Sine (aici) | Viteza urmează o sinusoidă, pornire lină și oprire lină. |
Enum.EasingStyle.Quad | Ca Sine, dar curba e puțin mai bruscă. |
Enum.EasingStyle.Linear | Viteză constantă, așa că fiecare zbor începe și se termină la viteză maximă. |
Direcția InOut: netezirea se aplică înainte în prima jumătate a zborului și invers în a doua, așa că camera accelerează de la un cadru și încetinește spre următorul.
Streaming
În place-urile noi, instance streaming e activ: implicit, dispozitivul jucătorului ține zona din jurul personajului său, așa că un cadru care se uită spre celălalt capăt al hărții poate arăta o lume goală. CutsceneService îi cere lui Roblox să încarce pentru acel jucător zona fiecărui cadru prin Player:RequestStreamAroundAsync: zona primului cadru înainte de trimiterea evenimentului, cu o așteptare de până la 2 secunde, și zona fiecărui cadru următor cu 2 secunde înainte să zboare camera spre el.
Roblox scrie că așa zona va fi probabil, dar nu sigur, încărcată și că efectul e temporar. Ține cadrele importante în raza de streaming sau folosește pe server Player:AddReplicationFocus pentru o zonă care trebuie să rămână încărcată până scoți focusul. Cu streamingul dezactivat, dispozitivul are oricum toată harta, iar pcall-ul din jurul fiecărei cereri înseamnă că o cerere eșuată nu poate opri cutscene-ul.
Ce e greșit în tutorialele vechi despre cutscene-uri
Dacă compari ghidul acesta cu un videoclip sau o postare de pe forum, iată diferențele care contează și de ce fiecare truc e o problemă.
| Tutorialul | Problema | Ghidul acesta |
|---|---|---|
Mișcă camera prin camera:Interpolate() | Roblox a marcat Interpolate ca învechit și recomandă animarea camerei prin TweenService. | Netezește fiecare zbor prin TweenService:GetValue și poziționează camera la fiecare cadru. |
Face tween pe camera.CFrame și nimic altceva | Focus rămâne unde l-au lăsat scripturile de cameră, lângă personaj, așa că lumina dinamică departe de el poate să nu se randeze (referința Roblox pentru Camera.Focus). | Setează Focus la fiecare cadru în render step. |
| Nu readuce camera | Jucătorul rămâne blocat uitându-se la ultimul cadru. | La final setează CameraType la Custom și CameraSubject pe Humanoid, și după Skip. |
Pornește cutscene-ul din Touched într-un LocalScript | Nimic nu-l împiedică să se repete la fiecare atingere, iar decizia se ia pe dispozitivul controlat de jucător. | Serverul alege jucătorul și ține minte cine l-a văzut deja. |
| Citește part-urile camerei pe client | Cu streamingul activ, part-urile departe de personaj pot încă să nu existe pe dispozitiv. | Serverul citește part-urile, trimite CFrame-urile lor și cere zona fiecărui cadru cu puțin înainte să ajungă camera acolo. |
Ce poate și ce nu poate schimba jucătorul
Consideră că un trișor controlează tot de pe dispozitivul lui: poate schimba sau șterge CutscenePlayer și poate trimite CutsceneEvent cu orice valoare. Pentru un cutscene asta nu înseamnă aproape nimic, dacă de el nu depinde nimic real.
| Trișorul încearcă | Rezultat |
|---|---|
| Să sară peste cutscene sau să nu-l redea deloc | Poate: e propriul lui ecran. Nu da niciodată o recompensă pentru "a urmărit cutscene-ul". |
Să trimită CutsceneEvent cu orice valoare | Face ceva doar numărul care se potrivește cu cutscene-ul lui curent, iar tot ce face e să-l dezghețe mai devreme. |
| Să atingă triggerul din orice punct al hărții | Posibil: fiecare dispozitiv își controlează personajul, iar documentația de securitate Roblox numește falsificarea evenimentelor Touched printre lucrurile pe care le poate face. Va vedea o dată acel cutscene și nu se va mai întâmpla nimic. |
| Să se miște oricum în timpul cutscene-ului | Nu are nimic de câștigat. Înghețarea îi împiedică pe jucătorii cinstiți să plece în mijlocul cutscene-ului; nu e o verificare de securitate. |
| Să pornească prin remote un cutscene altcuiva | Imposibil. Doar serverul poate trimite CutsceneEvent unui jucător, iar singurul lucru pe care dispozitivul îl poate trimite înapoi e "acest cutscene s-a terminat". |
Dacă un cutscene duce la ceva real, de exemplu la o ușă care apoi se deschide sau la apariția unui boss, lasă serverul să facă asta după propriul cronometru, nu când dispozitivul raportează că cutscene-ul s-a terminat.
Pasul 5: verifică
- Așază trei cadre Intro cu rândul pentru Command Bar. Dă-i cadrului 1
Caption"Welcome to the village", cadrului 2MoveSeconds2.5 șiCaption"Find the bridge", iar cadrul 3 lasă-l fără atribute. - Apasă Play (F5). Apar benzile negre, camera taie la cadrul 1 cu subtitrarea lui, zboară în 2.5 secunde spre cadrul 2, apoi în 3 secunde spre cadrul 3 fără subtitrare. Apoi camera revine în spatele personajului, iar lista de jucători reapare. Cât rulează, nu poți merge.
- Oprește testul, apasă din nou Play și apasă Skip cât camera zboară spre cadrul 2. Camera revine imediat și poți merge imediat.
- Intră în BridgeTrigger: rulează cutscene-ul Bridge. Treci prin el încă o dată: nu se întâmplă nimic.
- Alege Server & Clients din lista derulantă a modului de test, pune 2 clienți și apasă Play. Când Client 1 intră în trigger, cutscene-ul Bridge rulează doar la Client 1, iar Client 2 poate merge.
- Lasă
Workspace.StreamingEnabledactivat și mută un cadru departe de spawn. Când ajunge camera, mediul trebuie să fie la locul lui (probabil, dar nu garantat: vezi Streaming). - Pentru gamepad, oprește testul, apasă Play, deschide Controller Emulator (fila Emulation, apoi Controller) și intră în BridgeTrigger cu gamepad-ul emulat: Skip trebuie să fie selectat, așa că A sare peste cutscene. Dacă folosești Device Simulator din Studio (la verificarea noastră din 15 octombrie 2026 e beta: activeaz-o în File, Beta Features, New Device Simulator și repornește Studio), alege un telefon, întoarce-l orizontal și verifică faptul că Skip nu intră sub decupajul camerei și e ușor de nimerit, iar joystick-ul și butonul de săritură sunt ascunse cât merge cutscene-ul.
- Dacă ai făcut și un meniu principal, apasă Play, apoi butonul Play din meniu și lasă introul să ruleze până la capăt: după el lista de jucători trebuie să fie din nou pe ecran.
Ține fereastra Output deschisă (meniul Window, apoi Output) tot timpul. Când totul merge, scripturile acestea nu scriu nimic, așa că orice avertisment sau eroare roșie de la CutsceneService sau CutscenePlayer e o problemă reală. Vezi Erori frecvente.
Cum extinzi sistemul
Intro doar la prima intrare a jucătorului
Tabelul seen trăiește cât un server, așa că un jucător care a reintrat vede din nou introul. Ca să-l arăți doar la prima intrare, salvează un flag, de exemplu SeenIntro, împreună cu celelalte date ale jucătorului prin modulul PlayerData din tutorialul DataStore. Lasă INTRO_CUTSCENE cum e și schimbă partea din onCharacterAdded din CutsceneService care se ocupă de intro: așteaptă până când PlayerData.Get(player) returnează datele jucătorului, sari peste intro dacă data.SeenIntro e true și setează data.SeenIntro = true doar când playOnce(player, INTRO_CUTSCENE) a returnat true. Nu porni introul din codul care încarcă datele: datele se pot încărca înainte să apară personajul, iar fără personaj play nu face nimic, și flagul s-ar salva pentru un intro pe care nu l-a văzut nimeni.
Personaje care joacă în cutscene
Fă o animație în Animation Editor din Studio sau într-un plugin terț de animație, de exemplu Moon Animator, care e menționat în documentația Roblox, și red-o pe rigul unui NPC din cadru când ajunge camera acolo. Referința Roblox pentru Animator spune că animațiile NPC-urilor se replică doar dacă le încarcă și le pornește serverul, așa că red-o dintr-un Script de server dacă toți jucătorii trebuie să vadă cum joacă NPC-ul. Dacă o încarci și o pornești în CutscenePlayer, animația nu se replică, ceea ce e potrivit pentru un cutscene pe care îl urmărește un singur jucător. Ghidul despre scripturi de animație arată cum redai o animație pe un NPC dintr-un Script de server.
Dialoguri
Subtitrările sunt potrivite pentru replici scurte care merg singure. Pentru o conversație în care jucătorul răspunde și alege variante, vezi ghidul despre dialoguri cu NPC-uri.
Intro după meniul principal
Ghidul despre meniul principal dezactivează CharacterAutoLoads, așa că nimeni nu apare până nu apasă Play. CutsceneService redă introul la prima apariție a jucătorului, așa că, cu ambele sisteme, introul rulează la prima apariție după Play. Meniul reactivează core GUI-ul când apare personajul, iar asta se poate întâmpla când introul rulează deja, așa că în timpul introului poate fi vizibilă lista de jucători. CutscenePlayer reactivează doar ce a ascuns el, deci nu atinge modificarea meniului, iar după intro ele rămân activate. Trucul cu Command Bar din ghidul despre meniul principal, pentru poziționarea part-ului camerei, e același ca la pasul 1.
Survol al hărții la începutul rundei
Ca să pornești un cutscene din alt script de server, de exemplu un survol al hărții la începutul rundei din ghidul despre sistemul de runde, adaugă în ServerStorage un BindableEvent numit PlayCutscene. La finalul CutsceneService conectează-i Event-ul la funcția play, iar scriptul de runde să-l apeleze cu fiecare jucător și numele cutscene-ului. play sare peste verificarea "o dată pe server", așa că survolul rulează la fiecare rundă.
Pluginuri pentru cutscene-uri
Pluginurile se pot folosi împreună cu acest ghid. Dacă un plugin de cutscene-uri își scrie propriul script de cameră, verifică dacă readuce camera (CameraType Custom și CameraSubject) și dacă setează Focus cât camera e Scriptable, iar decizia despre cine vede cutscene-ul las-o pe server, ca în acest ghid.
Erori frecvente și soluții
Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play. Cele mai multe probleme cu cutscene-urile fie scriu acolo un avertisment, fie apar din cauza unui nume care nu se potrivește.
Infinite yield possible on 'Workspace:WaitForChild("Cutscenes")'
CutsceneService așteaptă un folder numit Cutscenes direct în Workspace. Creează-l ca la pasul 1 și verifică scrierea și C-ul mare. Cât timp lipsește, CutsceneService nu creează CutsceneEvent, așa că și CutscenePlayer așteaptă.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("CutsceneEvent")'
CutscenePlayer așteaptă remote-ul pe care îl creează CutsceneService. Verifică dacă CutsceneService e un Script, nu un LocalScript, stă direct în ServerScriptService, nu e dezactivat și nu are în Output o eroare sau un avertisment despre Cutscenes.
CutsceneService: no folder named Intro in Workspace.Cutscenes
Numele din INTRO_CUTSCENE sau din atributul Cutscene al triggerului nu se potrivește cu niciun folder din Workspace.Cutscenes. Majusculele din nume contează.
Nu rulează nimic, iar Output e gol
Folderul nu are un part numit 1 sau part-urile lui nu stau direct în el (de exemplu, sunt într-un Model). CutsceneService citește part-urile 1, 2, 3 în ordine și se oprește la primul număr lipsă. Și ține minte că fiecare cutscene rulează o dată pe jucător pe server: oprește testul și apasă din nou Play.
Camera se uită în altă parte
Camera se uită în aceeași direcție ca fața din față a part-ului-cadru. Du camera Studio la vederea dorită și rulează din nou rândul pentru Command Bar de la pasul 1 pentru acel cadru.
Triggerul nu face nimic
Verifică dacă part-ul-trigger stă direct în Workspace.CutsceneTriggers când pornește jocul, dacă CanTouch e bifat (altfel apare un avertisment în Output) și dacă atributul lui Cutscene e un string cu numele unui folder din Workspace.Cutscenes. O nouă trecere prin trigger nu face nimic, așa e gândit.
După cutscene camera rămâne pe ultimul cadru
CutscenePlayer s-a oprit cu o eroare înainte să readucă camera, așa că caută o eroare roșie de la el în Output. Camera o poate ține și alt script care setează mereu CameraType la Scriptable, de exemplu o cameră de meniu care e încă legată.
Fă-o cu RoCode
Dacă nu ai chef să construiești asta manual, RoCode o poate face în place-ul pe care îl ai deschis. RoCode este un agent AI independent pentru Roblox Studio, nu de la Roblox: descrii funcția în chatul lui web, iar pluginul lui pentru Studio creează part-ul și scripturile în Explorer-ul tău, așa că nu trebuie să copiezi cod din fereastra de chat.
Adaugă un cutscene de intro: un folder Cutscenes cu un folder Intro și cadrele de la 1 la 3, subtitrări din atributul Caption, benzi negre și un buton Skip, rulează o dată la prima apariție a jucătorului, serverul ține jucătorul pe loc, iar la final camera revine.
- Poate verifica întâi place-ul tău prin Search Scripts, de exemplu după un script de meniu sau de cameră care setează deja
CameraType, ca să nu intre în conflict - Creează folderele și part-ul-trigger prin Create Instance și setează pe part-uri atribute precum Caption și MoveSeconds
- Scrie CutsceneService și CutscenePlayer prin Create Script
- Are instrucțiuni să verifice fiecare script scris prin Check Script, care îl compilează în Studio fără să-l ruleze, și pune un punct de anulare înainte și după fiecare lot de modificări
Așază singur part-urile-cadru, ducând camera Studio la fiecare vedere, apoi cere scripturile. Cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.11 sau mai nou poate controla un personaj de test ca să verifice că jocul funcționează, dar în timpul jocului nu face capturi de ecran, așa că cutscene-ul îl urmărești tu. Ordinea în care construiești un joc întreg e pe pagina cum faci un joc în Roblox cu AI, sistem cu sistem. Cum se conectează RoCode la Studio.
Întrebări frecvente
Cum fac un cutscene să ruleze la intrarea în joc?
Numește folderul cu cadre Intro în Workspace.Cutscenes sau schimbă INTRO_CUTSCENE în numele folderului tău. CutsceneService îl redă la prima apariție a fiecărui jucător pe server. Ca să-l arăți doar la prima intrare din toate, salvează un flag într-un data store și setează-l doar după ce introul a început, cum e descris în secțiunea Cum extinzi sistemul.
Pot face un cutscene fără pluginuri?
Da. În ghidul acesta sunt doar part-uri, atribute și două scripturi, iar rândul pentru Command Bar pune fiecare cadru exact acolo unde stă camera Studio. Pluginuri precum Moon Animator sunt totuși utile ca să animezi personajele care joacă în cutscene.
De ce nu se mișcă camera în cutscene?
De obicei codul camerei stă într-un Script de server, dar camera jucătorului o poate mișca doar un LocalScript, pentru că fiecare dispozitiv are propria cameră. Altă cauză frecventă: CameraType nu e Scriptable, iar scripturile standard de cameră Roblox readuc mereu camera la personaj.
Cum îl împiedic pe jucător să se miște în timpul unui cutscene?
Ancorează-i HumanoidRootPart-ul pe server cât rulează și scoate ancorarea după, cum face CutsceneService. Un part ancorat nu se mișcă niciodată din cauza fizicii. WalkSpeed-ul nu e atins, așa că nu intră în conflict cu un script de sprint sau un pass de viteză.
Cum adaug un buton Skip la un cutscene?
Pune un TextButton pe ecranul cutscene-ului și conectează-i evenimentul Activated, care se declanșează la un clic, o atingere sau butonul A de pe gamepad când butonul e selectat. Skip din CutscenePlayer setează un flag pe care bucla de cadre îl verifică la fiecare cadru, se selectează singur pentru jucătorii cu gamepad și stă în propriul ScreenGui cu marginile implicite, ca decupajul camerei telefonului să nu-l acopere. Joystick-ul și butonul de săritură sunt ascunse cât merge cutscene-ul, așa că nu stau lângă el.
De ce e lumea goală în cutscene?
Cu instance streaming activ, dispozitivul jucătorului are doar zona din jurul personajului său. Lasă serverul să apeleze player:RequestStreamAroundAsync pentru fiecare cadru cu puțin înainte să ajungă camera acolo, cum face CutsceneService. Roblox scrie că așa zona va fi probabil, dar nu sigur, încărcată, așa că ține cadrele importante în raza de streaming sau folosește Player:AddReplicationFocus pentru o zonă care trebuie să rămână încărcată.
Surse și lecturi suplimentare
- Roblox Creator Docs: Customize the camera (în engleză). propria Camera a fiecărui client, Scriptable, CFrame și Focus
- Roblox Engine API: Camera (în engleză). CameraType, CameraSubject, Focus la fiecare cadru și Interpolate învechit
- Roblox Creator Docs: Control the user's camera (în engleză). BindToRenderStep cu un pas de prioritate după cameră
- Roblox Engine API: TweenService:GetValue (în engleză). alpha netezit, limitat între 0 și 1
- Roblox Engine API: ScreenGui.ScreenInsets (în engleză). de ce None doar pentru conținut pe care nu ai ce apăsa
- Roblox Creator Docs: Instance streaming (în engleză). activ implicit în place-urile noi și replication focus
- Roblox Creator Docs: Streaming techniques (în engleză). preîncărcarea zonei înainte de trimiterea evenimentului
- Roblox Engine API: Player:RequestStreamAroundAsync (în engleză). cerere temporară, fără garanție
- Roblox Creator Docs: Remote events and callbacks (în engleză). coada de mesaje și ce tabele se pot trimite
- Roblox Creator Docs: Network ownership, movement validation, and physics (în engleză). ce poate face clientul cu propriul personaj, inclusiv falsificarea evenimentelor Touched
- Roblox Engine API: Animator:LoadAnimation (în engleză). ce animații se replică
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.