En bref
Place des parts invisibles et ancrées nommées 1, 2, 3 dans un dossier de Workspace.Cutscenes, chacune tournée vers ce que la caméra doit regarder. Un Script dans ServerScriptService lit leurs CFrames, immobilise le joueur et lui envoie les plans avec un RemoteEvent. Un LocalScript dans StarterPlayerScripts règle workspace.CurrentCamera.CameraType sur Scriptable, déplace la caméra de plan en plan à chaque image (avec un easing via TweenService:GetValue), puis remet CameraType sur Custom et CameraSubject sur le Humanoid du joueur.
- Seul l'appareil du joueur peut déplacer sa caméra, donc le code de la caméra est un LocalScript. Le serveur décide seulement qui voit quelle cinématique et quand.
- Quand la caméra est Scriptable, Roblox arrête de mettre à jour
Camera.Focus. Sa référence dit de mettre Focus à jour à chaque image, sinon l'éclairage dynamique loin de l'ancien focus risque de ne pas s'afficher. Camera:Interpolateest obsolète (deprecated). La référence de Roblox dit d'animer la caméra avec TweenService à la place.
Sur cette page
Comment marche une cinématique
L'appareil de chaque joueur a son propre objet Camera, dans workspace.CurrentCamera, donc seul un LocalScript peut changer ce que voit ce joueur (en anglais). Décider qui voit quelle cinématique, et quand, c'est le travail du serveur. Ce guide partage le travail de cette façon. Une cinématique se passe comme ça :
- Le serveur décide qu'un joueur doit voir une cinématique : l'
Introà sa première apparition sur le serveur, ou une autre quand il touche une part déclencheur. - CutsceneService lit les CFrames et les réglages des parts de plan, demande à Roblox de streamer la zone du premier plan vers ce joueur, ancre le HumanoidRootPart du joueur pour qu'il reste sur place, et déclenche
CutsceneEventpour ce joueur seulement, avec un id et la liste des plans. - CutscenePlayer, sur l'appareil de ce joueur, affiche les bandes noires et le bouton Skip, cache la liste des joueurs, le sac (backpack), la barre de vie et les commandes tactiles, rend la caméra Scriptable et la déplace à chaque image.
- Quand le dernier plan se termine, ou que le joueur appuie sur Skip, il rend la caméra au personnage et déclenche
CutsceneEventvers le serveur avec le même id. - Le serveur désancre le joueur. Si ce message n'arrive jamais, il le désancre quand même une fois passée la durée de la cinématique plus 2 secondes. Ce minuteur démarre quand le serveur envoie la cinématique, et si le joueur se connecte lentement, l'appareil peut lancer l'intro quelques secondes plus tard, parce que les LocalScripts hors de ReplicatedFirst ne tournent pas avant que le jeu soit chargé. Dans ce cas, le joueur peut de nouveau bouger avant la fin de l'intro sur son écran.
| Élément | Où il se trouve | Ce qu'il fait |
|---|---|---|
Le Script CutsceneService | ServerScriptService | Décide qui voit quelle cinématique et quand, lit les plans, immobilise le joueur et retient qui a vu quoi. |
Le LocalScript CutscenePlayer | StarterPlayer, StarterPlayerScripts | Joue une cinématique sur l'écran du joueur : bandes, sous-titres, Skip et mouvements de caméra. Rend la caméra à la fin. |
Le RemoteEvent CutsceneEvent | ReplicatedStorage (CutsceneService le crée) | Transporte les plans du serveur vers un joueur, et le message "cinématique terminée" dans l'autre sens. |
Le dossier Cutscenes | Workspace | Un dossier par cinématique, comme Intro, qui contient les parts de plan nommées 1, 2, 3. |
Le dossier CutsceneTriggers | Workspace (facultatif) | Des parts qui lancent une cinématique quand un joueur les touche. |
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
Étape 1 : placer les plans de caméra
Chaque plan est une part invisible. La caméra prend la position de la part et regarde dans la même direction que sa face avant, donc placer un plan revient à placer la caméra.
- Dans l'Explorer, survole Workspace, clique sur le bouton + et insère un Folder nommé
Cutscenes. Dedans, insère un Folder nomméIntro. Les noms tiennent compte des majuscules. - Fais voler la caméra de Studio jusqu'à la première vue que tu veux, comme si tu cadrais une photo.
- Insère une Part dans Intro et renomme-la
1. - Ouvre la Command Bar (dans l'onglet Script, ou Window, puis Script) et lance
workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. En mode édition,CurrentCameraest la vue à travers laquelle tu regardes, donc la part saute exactement sur ce plan. Les crochets et les guillemets sont nécessaires parce qu'un nom qui commence par un chiffre ne peut pas suivre un point. - Dans les Properties de la part, coche Anchored, décoche CanCollide, CanTouch et CanQuery, et règle Transparency sur 1. Anchored l'empêche de tomber à travers la carte ; les autres l'empêchent de bloquer les joueurs, de déclencher des événements de contact et de gêner les raycasts.
- Recommence pour les vues suivantes, en nommant les parts
2,3et ainsi de suite, et en changeant le numéro dans la ligne de la Command Bar. CutsceneService joue les plans dans l'ordre des numéros et s'arrête au premier numéro manquant, donc un trou termine la cinématique trop tôt.
Pour changer un plan plus tard, fais voler la caméra jusqu'à la nouvelle vue et relance la même ligne avec le numéro de ce plan. Avec Transparency à 1, les parts sont invisibles dans Studio aussi, donc sélectionne-les dans l'Explorer quand tu en as besoin.
Chaque plan peut aussi avoir trois attributs facultatifs. Pour en ajouter un, sélectionne la part, descends jusqu'à la section Attributes de la fenêtre Properties, clique sur +, entre le nom, choisis le type et clique sur Save.
| Attribut | Type | Par défaut | Ce qu'il fait |
|---|---|---|---|
MoveSeconds | number | 3 | Secondes que met la caméra pour glisser du plan précédent jusqu'à celui-ci. 0 en fait une coupe. Le plan 1 est toujours une coupe, donc il l'ignore. |
HoldSeconds | number | 1 | Secondes pendant lesquelles la caméra reste sur ce plan après y être arrivée. |
Caption | string | aucun | Texte affiché dans la bande du bas dès que la caméra commence à aller vers ce plan. Un plan sans Caption efface le texte. |
Un nombre en dessous de 0 ou au-dessus de 60, ou un attribut du mauvais type, revient à la valeur par défaut.
Étape 2 : ajouter le script serveur
Survole ServerScriptService, insère un Script nommé CutsceneService et colle le code ci-dessous. Les réglages en haut sont les lignes faites pour être modifiées.
-- Script dans ServerScriptService nommé CutsceneService.
-- Décide qui voit quelle cinématique et quand. Il lit les plans de caméra dans des parts
-- numérotées de Workspace.Cutscenes, immobilise le joueur et dit à l'appareil de ce joueur
-- de jouer les plans. La caméra elle-même ne peut être déplacée que sur l'appareil.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Réglages
local INTRO_CUTSCENE = "Intro" -- joue une fois à la première apparition d'un joueur ; "" pour aucune
local DEFAULT_MOVE_SECONDS = 3 -- durée du glissement vers un plan sans MoveSeconds
local DEFAULT_HOLD_SECONDS = 1 -- durée de pause sur un plan sans HoldSeconds
local MAX_SHOTS = 30
local cutscenes = workspace:WaitForChild("Cutscenes")
local triggers = workspace:FindFirstChild("CutsceneTriggers")
-- Ce script crée CutsceneEvent lui-même, donc n'en ajoute pas à la main
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 } = {} -- l'id de la cinématique que regarde un joueur
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
-- Les plans sont des parts nommées 1, 2, 3 ... dans un dossier qui porte le nom de la cinématique
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,
-- le premier plan est une coupe, donc la caméra y saute directement
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 -- cette cinématique est déjà finie
end
playing[player] = nil
setFrozen(player, false)
end
local function play(player: Player, name: string): boolean
if playing[player] then
return false -- une cinématique à la fois
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
-- Avec l'instance streaming activé, l'appareil du joueur peut ne pas avoir la zone que regarde
-- un plan, et une demande ne charge une zone que pour un moment. Charge la zone du premier
-- plan maintenant (en attendant jusqu'à 2 secondes), et celle de chaque plan suivant 2 secondes
-- avant que la caméra commence à s'y déplacer.
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 -- le joueur est parti pendant le chargement de la zone
end
setFrozen(player, true)
cutsceneEvent:FireClient(player, id, shots)
local startsAt = 0 -- secondes d'ici à ce que la caméra commence à aller vers ce plan
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
-- Filet de sécurité : libère le joueur même si son appareil ne répond jamais
task.delay(startsAt + 2, finish, player, id)
return true
end
-- Renvoie true seulement quand la cinématique a démarré pour ce joueur
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
-- L'appareil du joueur signale que la cinématique est finie ou a été passée
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
if typeof(id) == "number" then
finish(player, id)
end
end)
-- Parts déclencheurs : en toucher un joue la cinématique nommée dans son attribut Cutscene
if triggers then
for _, trigger in triggers:GetChildren() do
if not trigger:IsA("BasePart") then
continue
end
if not trigger.CanTouch then
-- Connecter Touched sur une part avec CanTouch désactivé lève une erreur, donc on avertit à la place
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) -- réapparu pendant une cinématique, donc on immobilise aussi le nouveau personnage
elseif INTRO_CUTSCENE ~= "" then
playOnce(player, INTRO_CUTSCENE)
end
end
local function onPlayerAdded(player: Player)
if seen[player] then
return -- déjà préparé
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 -- ceux qui sont arrivés pendant que ce script attendait Cutscenes
onPlayerAdded(player)
end
Players.PlayerRemoving:Connect(function(player: Player)
seen[player] = nil
playing[player] = nil
end)
CutsceneService crée lui-même le RemoteEvent CutsceneEvent, une fois que Workspace.Cutscenes existe, donc il n'y a rien à insérer à la main dans ReplicatedStorage. Si tu as déjà fait un RemoteEvent avec ce nom, supprime-le : le LocalScript pourrait trouver le tien, que rien n'écoute sur le serveur.
| Réglage | Valeur ici | Ce qu'il change |
|---|---|---|
INTRO_CUTSCENE | "Intro" | Le dossier de Workspace.Cutscenes joué quand un joueur apparaît pour la première fois sur un serveur. Mets "" pour ne pas avoir d'intro. |
DEFAULT_MOVE_SECONDS | 3 | La durée d'un glissement quand un plan n'a pas d'attribut MoveSeconds. |
DEFAULT_HOLD_SECONDS | 1 | Le temps que la caméra reste sur un plan qui n'a pas d'attribut HoldSeconds. |
MAX_SHOTS | 30 | Le plus grand numéro de plan que CutsceneService cherche dans une cinématique. |
Ce que fait le reste du script, dans l'ordre :
- Lit les plans sur le serveur.
readShotsrassemble le CFrame et les attributs de chaque part numérotée dans une liste. L'appareil du joueur reçoit cette liste, donc il n'a jamais besoin des parts elles-mêmes. - Une cinématique à la fois.
playne fait rien tant que le joueur en regarde déjà une, ou quand son personnage n'a pas de Humanoid ou est mort. - Un id pour chaque cinématique. L'appareil renvoie l'id quand la cinématique se termine ou est passée, et seul l'id qui correspond libère le joueur, donc un message en retard d'une cinématique précédente ne peut pas en terminer une plus récente.
- Immobilise le joueur en ancrant son HumanoidRootPart, et ancre aussi le nouveau personnage si le joueur réapparaît pendant la cinématique. La référence de Roblox dit qu'une part ancrée ne change jamais de position à cause de la gravité, des collisions ou de toute autre physique. WalkSpeed n'est pas touché, donc ça ne peut pas entrer en conflit avec un script de sprint ou un pass de vitesse. À la fin, il désancre la part racine même si un autre script l'avait ancrée, donc n'ancre pas les personnages ailleurs tant qu'une cinématique peut se jouer.
- Un filet de sécurité.
task.delaylibère le joueur après la durée totale de la cinématique plus 2 secondes, même si son appareil ne répond jamais. - Joue chaque cinématique une fois par serveur. La table
seenretient, pour chaque joueur, quelles cinématiques ont démarré, donc l'intro ne se rejoue pas à la réapparition et une cinématique de déclencheur se joue une fois.playOncene renvoie true que si la cinématique a vraiment démarré. - Prépare chaque joueur. La boucle sur
Players:GetPlayers()à la fin attrape tous ceux qui sont arrivés pendant que le script attendait le dossier Cutscenes.
Les plans partent vers le joueur en un seul appel à FireClient, sous forme de liste de petites tables. La page des remote events de Roblox dit de ne pas envoyer une table qui mélange des clés numériques et des clés texte ; cette liste n'a que des clés numériques, et chaque plan dedans n'a que des clés texte, ce qui est la forme demandée.
Étape 3 : ajouter le LocalScript qui la joue
- Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts et insère un LocalScript nommé
CutscenePlayer. - Remplace son contenu par le code ci-dessous.
-- LocalScript dans StarterPlayer > StarterPlayerScripts nommé CutscenePlayer.
-- Joue une cinématique envoyée par le serveur : bandes noires, sous-titres, bouton Skip et
-- caméra qui glisse de plan en plan. Puis il rend la caméra au joueur.
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 -- chaque bande noire, en part de la hauteur de l'écran
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- studs devant la caméra que Roblox doit rendre avec le plus de détails
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 }
-- L'écran de la cinématique : deux bandes noires et un sous-titre, d'un bord à l'autre. Roblox dit
-- de n'utiliser ScreenInsets None que pour ce qu'on ne presse pas, donc Skip a son propre ScreenGui plus bas.
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- couvrir tout l'écran
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
-- Le bouton Skip garde les marges par défaut, donc il reste à l'écart des encoches de caméra
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) -- sur la bande du bas, à droite
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
-- Garde Skip assez grand pour être touché sur un petit écran de téléphone
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
-- Le mouvement en cours : d'un CFrame de caméra au suivant en un certain nombre de secondes
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false
-- Tourne à chaque image pendant une cinématique. Le Focus d'une caméra Scriptable ne suit
-- rien tout seul, donc il est réglé ici aussi.
local function updateCamera()
if camera.CameraType ~= Enum.CameraType.Scriptable then
camera.CameraType = Enum.CameraType.Scriptable -- quelque chose l'a réinitialisée, comme une réapparition
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
-- Une est déjà en cours, donc on laisse le serveur libérer le joueur pour celle-ci tout de suite
cutsceneEvent:FireServer(id)
return
end
busy = true
skipRequested = false
-- Cache la liste des joueurs, le sac et la barre de vie, en notant ce qui était affiché
local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
for _, coreGui in HIDDEN_CORE_GUIS do
wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
StarterGui:SetCoreGuiEnabled(coreGui, false)
end
-- Sur téléphone, cache le joystick et le bouton de saut, qui sont dans les coins du bas
local touchControlsWere = GuiService.TouchControlsEnabled
GuiService.TouchControlsEnabled = false
gui.Enabled = true
controls.Enabled = true
-- Une manette ne peut presser qu'un bouton sélectionné, donc on sélectionne Skip pour les joueurs à la manette
if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
GuiService.SelectedObject = skipButton
end
camera = workspace.CurrentCamera
camera.CameraType = Enum.CameraType.Scriptable
moveTo = camera.CFrame
-- Un cran après la mise à jour de caméra de Roblox, comme le fait le tutoriel caméra de Roblox
RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)
for _, shot in shots do
moveFrom = camera.CFrame -- chaque mouvement part de là où est la caméra maintenant
moveTo = shot.cframe
moveStart = os.clock()
moveSeconds = shot.move
caption.Text = shot.caption
waitOrSkip(shot.move + shot.hold)
if skipRequested then
break
end
end
-- Rend la caméra au personnage du joueur
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 = ""
-- Ne rallume que ceux que cette cinématique a éteints, et laisse le reste tel quel
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) -- permet au serveur de libérer le joueur maintenant
busy = false
end
skipButton.Activated:Connect(function()
skipRequested = true
end)
cutsceneEvent.OnClientEvent:Connect(function(id: number, shots: { Shot })
play(id, shots)
end)
Un LocalScript dans StarterPlayerScripts est copié chez le joueur une seule fois, quand il arrive, et continue de tourner quand son personnage réapparaît. C'est pour ça que les deux ScreenGuis ont ResetOnSpawn désactivé : activé, Roblox les supprimerait à la première réapparition, et ce script ne les referait pas. Les messages remote qui arrivent avant que le script se connecte à OnClientEvent sont mis en file d'attente et livrés dès qu'il le fait, donc un joueur qui apparaît vite voit quand même l'intro.
| Partie | Ce qu'elle fait |
|---|---|
Le ScreenGui Cutscene | Deux bandes noires, chacune de 12 % de la hauteur de l'écran (BAR_HEIGHT), avec le sous-titre dans la bande du bas. ScreenInsets None laisse les bandes aller jusqu'aux bords de l'écran, et DisplayOrder 10 les dessine au-dessus des ScreenGuis qui ont un DisplayOrder plus bas. |
Le ScreenGui CutsceneControls | Contient seulement le bouton Skip, à droite de la bande du bas, avec un UISizeConstraint qui le garde à au moins 64 sur 32 pixels pour qu'il reste facile à toucher sur un téléphone. Il garde les ScreenInsets par défaut, qui tiennent son contenu à l'écart des boutons de la barre du haut de Roblox et des encoches de caméra. Roblox dit de n'utiliser None que pour un contenu sur lequel on n'appuie pas, donc Skip ne peut pas partager le ScreenGui des bandes. |
HIDDEN_CORE_GUIS | Cache la liste des joueurs, le sac et la barre de vie avec SetCoreGuiEnabled, après avoir noté lesquels étaient affichés avec GetCoreGuiEnabled, et à la fin ne rallume que ceux qu'il a éteints. Un jeu qui cache le sac ailleurs le garde caché, et un script qui les rallume pendant la cinématique, comme un menu principal, n'est pas dérangé. |
TouchControlsEnabled | Sur téléphone et tablette, play règle GuiService.TouchControlsEnabled sur false pendant la cinématique. Ça cache le joystick et le bouton de saut, qui sont dans les coins du bas, là où se trouve Skip, et ils reviennent à la fin s'ils étaient affichés. |
updateCamera | Tourne à chaque image pendant une cinématique. Il calcule où en est le mouvement en cours, applique l'easing avec TweenService:GetValue, place la caméra entre les deux plans avec CFrame:Lerp, et règle Focus 30 studs devant la caméra. |
waitOrSkip | Attend le temps de mouvement et de pause d'un plan, en vérifiant le drapeau Skip à chaque image. |
play | Rend la caméra Scriptable, joue les plans dans l'ordre, puis rend la caméra (CameraType Custom, CameraSubject le Humanoid), rallume les core GUIs et les commandes tactiles et envoie l'id de la cinématique au serveur. Si une deuxième cinématique arrive pendant qu'une autre joue encore, il renvoie tout de suite son id, pour que le serveur n'immobilise pas le joueur pour une cinématique que cet appareil n'a pas montrée. |
| Le bouton Skip | Activated se déclenche pour un clic de souris, un toucher, ou le bouton A d'une manette une fois le bouton sélectionné. Pour un joueur dont l'entrée préférée est une manette, play sélectionne Skip au début de la cinématique et efface la sélection à la fin. |
Change BAR_HEIGHT pour des bandes plus fines ou plus épaisses, et EASING_STYLE pour changer le ressenti des mouvements (vois Ce que le code de la caméra fait bien). Le sous-titre et le bouton Skip utilisent TextScaled, donc leur texte grandit et rétrécit avec l'écran.
Étape 4 : jouer une cinématique quand un joueur touche une part
L'intro se joue toute seule. Pour une cinématique à un endroit de ta carte, par exemple la première fois qu'un joueur arrive à un pont, ajoute une deuxième cinématique et une part déclencheur.
- Dans Workspace, Cutscenes, insère un Folder nommé
Bridgeet place ses plans comme à l'étape 1, nommés1et2. Dans la ligne de la Command Bar, utiliseBridgeau lieu deIntro. - Survole Workspace et insère un Folder nommé
CutsceneTriggers. - Insère dedans une Part nommée
BridgeTrigger. Fais-la assez grande pour que les joueurs ne puissent pas passer à côté sans la toucher, par exemple une grande dalle haute en travers du chemin. Coche Anchored, décoche CanCollide et CanQuery, garde CanTouch coché, et règle Transparency sur 1. CanQuery désactivé empêche la dalle invisible de bloquer les raycasts, comme les tirs du guide de l'arme à feu (en anglais). Les événements de contact dépendent de CanTouch, pas de CanQuery, donc le déclencheur marche quand même. - Ajoute-lui un attribut nommé
Cutscene, de type string, et mets sa valeur surBridge: le nom du dossier à jouer.
CutsceneService connecte Touched sur chaque part directement dans CutsceneTriggers au démarrage du serveur, donc ajoute les déclencheurs dans Studio, pas depuis un script pendant que le jeu tourne. Un déclencheur avec CanTouch désactivé est ignoré avec un avertissement dans Output, parce que Roblox lève une erreur quand un script connecte Touched sur une telle part.
Touched se déclenche de nombreuses fois d'affilée pendant qu'un personnage traverse une part. La table seen et la règle d'une cinématique à la fois en font une seule cinématique par joueur et par serveur. Un joueur qui touche le déclencheur pendant qu'une autre cinématique joue est ignoré, et le déclencheur reste prêt pour lui.
Garde les déclencheurs loin des routes. Le HumanoidRootPart d'un joueur assis est soudé (weld) au siège, et quand une part d'un groupe soudé est ancrée, Roblox ancre le reste avec. Un joueur qui roule dans un déclencheur immobilise donc tout son véhicule, passagers compris, jusqu'à la fin de la cinématique.
Ce que le code de la caméra fait bien
Scriptable, puis retour à Custom
Les scripts de caméra de Roblox ne déplacent pas et ne mettent pas à jour la caméra tant que CameraType est Scriptable, et c'est ce qui permet à CutscenePlayer de la placer. À la fin, il remet CameraType sur Custom et fait du Humanoid du joueur le CameraSubject, que les scripts de caméra de Roblox suivent par défaut. Ça se fait aussi après un Skip, donc le joueur ne reste jamais bloqué sur le dernier plan.
Deux petites protections gardent la cinématique aux commandes pendant qu'elle joue. Si quoi que ce soit change CameraType en cours de cinématique, la fonction appelée à chaque image le remet sur Scriptable à l'image suivante. Et le script relit workspace.CurrentCamera au début de chaque cinématique, parce que Roblox crée une nouvelle Camera si l'actuelle est détruite.
Focus, à chaque image
Camera.Focus indique au moteur quelle zone traiter en priorité pour des choses comme l'éclairage. Les scripts de caméra de Roblox le gardent sur le CameraSubject, mais pas quand la caméra est Scriptable, et la référence de Roblox dit de le mettre à jour à chaque image dans ce cas : l'éclairage dynamique d'objets comme les PointLights risque de ne pas s'afficher loin du focus. CutscenePlayer le place 30 studs devant la caméra (FOCUS_DISTANCE). Augmente cette valeur si tes plans regardent quelque chose de plus lointain.
La fonction tourne via RunService:BindToRenderStep, à chaque image avant qu'elle soit dessinée, un cran de priorité après la mise à jour de caméra de Roblox (Enum.RenderPriority.Camera.Value + 1). C'est la priorité qu'utilise le tutoriel caméra de Roblox, donc la cinématique place la caméra après le passage du code de caméra de Roblox.
Easing avec TweenService:GetValue
Un tween sur camera.CFrame déplacerait la caméra, mais le Focus doit quand même être réglé à chaque image, donc CutscenePlayer fait le mouvement lui-même dans la même fonction. Pour chaque mouvement, il calcule la part du temps de mouvement déjà écoulée (de 0 à 1), la passe dans TweenService:GetValue avec un style et une direction d'easing, et place la caméra à cette distance entre les deux plans avec CFrame:Lerp, qui déplace la position en ligne droite et tourne la rotation en douceur. GetValue limite son entrée entre 0 et 1, donc la caméra s'arrête pile sur le plan quand le temps de mouvement est écoulé.
| EASING_STYLE | Ressenti du mouvement |
|---|---|
Enum.EasingStyle.Sine (utilisé ici) | La vitesse suit une sinusoïde, pour un départ et un arrêt en douceur. |
Enum.EasingStyle.Quad | Comme Sine, avec une courbe un peu plus marquée. |
Enum.EasingStyle.Linear | Vitesse constante, donc chaque mouvement démarre et s'arrête à pleine vitesse. |
La direction est InOut : l'easing s'applique à l'endroit pendant la première moitié du mouvement et à l'envers pendant la seconde, donc la caméra accélère en quittant un plan et ralentit en arrivant au suivant.
Streaming
Les nouveaux jeux ont l'instance streaming activé : par défaut, l'appareil d'un joueur garde la zone autour de son personnage, donc un plan qui regarde l'autre bout de la carte peut montrer un monde vide. CutsceneService demande à Roblox de streamer la zone de chaque plan vers ce joueur avec Player:RequestStreamAroundAsync : la zone du premier plan avant de déclencher l'événement, en attendant jusqu'à 2 secondes, et celle de chaque plan suivant 2 secondes avant que la caméra commence à s'y déplacer.
Roblox dit que ça rend le chargement de la zone probable, pas certain, et que l'effet est temporaire. Garde les plans importants dans ton rayon de streaming, ou utilise Player:AddReplicationFocus sur le serveur pour une zone qui doit rester chargée jusqu'à ce que tu retires le focus. Avec le streaming désactivé, l'appareil a de toute façon toute la carte, et le pcall autour de chaque demande fait qu'une demande qui échoue ne peut pas arrêter la cinématique.
Ce que les anciens tutoriels de cinématique font mal
Si tu compares ce guide avec une vidéo ou un post de forum, voici les différences qui comptent, avec la raison pour laquelle chaque méthode pose problème.
| Le tutoriel | Le problème | Ce guide |
|---|---|---|
Déplace la caméra avec camera:Interpolate() | Roblox marque Interpolate comme obsolète et dit d'animer la caméra avec TweenService à la place. | Applique l'easing à chaque mouvement avec TweenService:GetValue et place la caméra à chaque image. |
Tweene camera.CFrame et rien d'autre | Focus reste là où les scripts de caméra l'ont laissé, près du personnage, donc l'éclairage dynamique loin de lui risque de ne pas s'afficher (référence Camera.Focus de Roblox). | Règle Focus à chaque image dans le render step. |
| Ne rend jamais la caméra | Le joueur reste bloqué sur le dernier plan. | Remet CameraType sur Custom et CameraSubject sur le Humanoid à la fin, après un Skip aussi. |
Lance la cinématique depuis Touched dans un LocalScript | Rien ne l'empêche de se relancer à chaque contact, et la décision se prend sur un appareil que le joueur contrôle. | Le serveur choisit le joueur et retient qui l'a vue. |
| Lit les parts de caméra sur le client | Avec le streaming activé, les parts loin du personnage peuvent ne pas encore exister sur l'appareil. | Le serveur lit les parts, envoie leurs CFrames et demande la zone de chaque plan peu avant que la caméra y arrive. |
Ce qu'un joueur peut changer ou non
Pars du principe qu'un tricheur contrôle tout sur son propre appareil : il peut modifier ou supprimer CutscenePlayer et déclencher CutsceneEvent avec n'importe quelle valeur. Pour une cinématique, ça compte très peu, tant que rien de réel n'en dépend.
| Un tricheur essaie de | Résultat |
|---|---|
| Passer une cinématique, ou ne jamais la jouer | Autorisé : c'est son propre écran. Ne donne jamais de récompense pour "a fini la cinématique". |
Déclencher CutsceneEvent avec n'importe quelle valeur | Seul un nombre qui correspond à sa propre cinématique en cours fait quelque chose, et tout ce que ça fait, c'est le libérer plus tôt. |
| Toucher un déclencheur depuis n'importe où sur la carte | Possible : chaque appareil contrôle son propre personnage, et la documentation de sécurité de Roblox cite la manipulation des événements Touched parmi ce qu'il peut faire. Il voit cette cinématique une fois, et rien d'autre ne se passe. |
| Bouger quand même pendant une cinématique | Rien à y gagner. L'immobilisation empêche les joueurs honnêtes de partir en pleine cinématique ; ce n'est pas une vérification de sécurité. |
| Utiliser le remote pour lancer une cinématique chez quelqu'un d'autre | Impossible. Seul le serveur déclenche CutsceneEvent vers un joueur, et le seul message qu'un appareil peut renvoyer est "cette cinématique est terminée". |
Si une cinématique mène à quelque chose de réel, comme une porte qui s'ouvre après ou un boss qui apparaît, laisse le serveur le faire avec son propre minuteur, pas quand l'appareil dit que la cinématique est finie.
Étape 5 : la tester
- Place les trois plans de l'Intro avec la ligne de la Command Bar. Donne au plan 1 la
Caption"Welcome to the village", donne au plan 2MoveSeconds2.5 et laCaption"Find the bridge", et laisse le plan 3 sans attributs. - Appuie sur Play (F5). Les bandes noires apparaissent et la caméra coupe sur le plan 1 avec son sous-titre, glisse jusqu'au plan 2 en 2,5 secondes, puis jusqu'au plan 3 en 3 secondes sans sous-titre. La caméra revient ensuite derrière ton personnage et la liste des joueurs réapparaît. Tu ne peux pas marcher pendant qu'elle joue.
- Arrête, appuie de nouveau sur Play, et appuie sur Skip pendant que la caméra glisse vers le plan 2. La caméra revient tout de suite, et tu peux marcher immédiatement.
- Marche dans BridgeTrigger : la cinématique Bridge se joue. Retraverse-le : rien ne se passe.
- Choisis Server & Clients dans le menu déroulant du mode de test, règle 2 clients et appuie sur Play. Quand Client 1 entre dans le déclencheur, la cinématique Bridge ne se joue que sur Client 1, et Client 2 peut toujours marcher.
- Laisse
Workspace.StreamingEnabledactivé et déplace un plan loin du point d'apparition. Le décor devrait être là quand la caméra arrive (probablement, sans garantie : vois Streaming). - Pour une manette, arrête, appuie sur Play, ouvre le Controller Emulator (onglet Emulation, puis Controller) et entre dans BridgeTrigger avec la manette émulée : Skip devrait être sélectionné, donc A passe la cinématique. Si tu utilises le Device Simulator de Studio (une bêta quand nous avons vérifié le 15 octobre 2026 : active-le dans File, Beta Features, New Device Simulator, puis redémarre Studio), choisis un téléphone, passe-le en paysage et vérifie que Skip est à l'écart de l'encoche de la caméra et facile à toucher, et que le joystick et le bouton de saut sont cachés pendant la cinématique.
- Si tu as aussi construit le menu principal, appuie sur Play, puis sur le bouton Play du menu, et laisse l'intro aller jusqu'au bout : la liste des joueurs devrait être de retour à l'écran ensuite.
Garde la fenêtre Output ouverte (menu Window, puis Output) tout le temps. Ces scripts n'affichent rien quand ils marchent, donc tout avertissement ou toute erreur rouge de CutsceneService ou de CutscenePlayer est un vrai problème. Vois Problèmes courants.
Aller plus loin
Montrer l'intro seulement à la première visite d'un joueur
La table seen dure le temps d'un serveur, donc un joueur qui revient revoit l'intro. Pour ne la montrer qu'à sa première visite, sauvegarde un drapeau comme SeenIntro avec le reste de ses données, avec le module PlayerData du tutoriel DataStore. Garde INTRO_CUTSCENE tel quel et change la partie intro de onCharacterAdded dans CutsceneService : attends que PlayerData.Get(player) renvoie les données du joueur, saute l'intro quand data.SeenIntro vaut true, et règle data.SeenIntro = true seulement quand playOnce(player, INTRO_CUTSCENE) renvoie true. Ne lance pas l'intro depuis le code qui charge les données : les données peuvent finir de charger avant que le personnage apparaisse, et play ne fait rien sans personnage, donc le drapeau serait sauvegardé pour une intro que personne n'a vue.
Des personnages qui jouent dans la cinématique
Crée l'animation dans l'Animation Editor de Studio, ou dans un plugin d'animation tiers comme Moon Animator, que la documentation de Roblox mentionne elle-même, et joue-la sur un rig de PNJ dans le plan quand la caméra y arrive. La référence Animator de Roblox dit que les animations d'un PNJ ne sont répliquées que si le serveur les charge et les lance, donc joue-la depuis un Script serveur si tous les joueurs doivent voir le PNJ jouer. Chargée et lancée dans CutscenePlayer à la place, l'animation n'est pas répliquée, ce qui convient à une cinématique qu'un seul joueur regarde. Le guide du script d'animation montre comment en jouer une sur un PNJ depuis un Script serveur.
Dialogues
Les sous-titres conviennent aux phrases courtes qui défilent toutes seules. Pour une conversation où le joueur répond et fait des choix, vois le guide des dialogues de PNJ.
Une intro après le menu principal
Le guide du menu principal désactive CharacterAutoLoads, donc personne n'apparaît avant d'avoir appuyé sur Play. CutsceneService joue l'intro à la première apparition d'un joueur, donc avec les deux systèmes, l'intro se joue à la première apparition après Play. Le menu rallume les core GUIs dès que le personnage apparaît, ce qui peut arriver pendant que l'intro joue déjà, donc la liste des joueurs peut s'afficher pendant l'intro. CutscenePlayer ne rallume que ceux qu'il a cachés lui-même, donc il ne touche pas au changement du menu, et ils restent affichés après l'intro. L'astuce de la Command Bar du guide du menu principal pour viser avec une part de caméra est la même que celle de l'étape 1.
Un survol au début d'une manche
Pour lancer une cinématique depuis un autre script serveur, comme un survol de la carte au début d'une manche du guide du système de manches, ajoute un BindableEvent nommé PlayCutscene dans ServerStorage. À la fin de CutsceneService, connecte son Event à la fonction play, et fais-le déclencher par le script des manches avec chaque joueur et le nom de la cinématique. play saute la vérification d'une fois par serveur, donc le survol se joue à chaque manche.
Plugins de cinématique
Tu peux utiliser des plugins en plus de ce guide. Si un plugin de cinématique écrit son propre script de caméra, vérifie qu'il rend la caméra (CameraType Custom et un CameraSubject) et qu'il règle Focus pendant que la caméra est Scriptable, et garde sur le serveur la décision de qui voit la cinématique, comme dans ce guide.
Problèmes courants
Ouvre la fenêtre Output (menu Window, puis Output) avant d'appuyer sur Play. La plupart des problèmes de cinématique affichent un avertissement là, ou viennent d'un nom qui ne correspond pas.
Infinite yield possible on 'Workspace:WaitForChild("Cutscenes")'
CutsceneService attend un dossier nommé Cutscenes directement dans Workspace. Crée-le comme à l'étape 1 et vérifie l'orthographe et le C majuscule. Tant qu'il n'existe pas, CutsceneService ne crée pas CutsceneEvent, donc CutscenePlayer attend aussi.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("CutsceneEvent")'
CutscenePlayer attend le remote que crée CutsceneService. Vérifie que CutsceneService est un Script, pas un LocalScript, directement dans ServerScriptService, qu'il n'est pas désactivé, et qu'Output n'affiche ni erreur ni avertissement Cutscenes venant de lui.
CutsceneService: no folder named Intro in Workspace.Cutscenes
Le nom dans INTRO_CUTSCENE, ou dans l'attribut Cutscene d'un déclencheur, ne correspond à aucun dossier de Workspace.Cutscenes. Les noms tiennent compte des majuscules.
Rien ne se joue, et Output n'affiche rien
Le dossier n'a pas de part nommée 1, ou ses parts ne sont pas directement dedans (par exemple, elles sont dans un Model). CutsceneService lit les parts nommées 1, 2, 3 dans l'ordre et s'arrête au premier numéro manquant. N'oublie pas non plus que chaque cinématique se joue une fois par joueur et par serveur : arrête le test et appuie de nouveau sur Play.
La caméra regarde dans la mauvaise direction
La caméra regarde dans la même direction que la face avant de la part de plan. Fais voler la caméra de Studio jusqu'à la vue que tu veux et relance la ligne de la Command Bar de l'étape 1 pour ce plan.
Le déclencheur ne fait rien
Vérifie que la part déclencheur est directement dans Workspace.CutsceneTriggers au démarrage du jeu, que CanTouch est coché (Output affiche un avertissement sinon), et que son attribut Cutscene est un string qui nomme un dossier de Workspace.Cutscenes. Le traverser une deuxième fois ne fait rien, c'est voulu.
La caméra reste sur le dernier plan après la cinématique
CutscenePlayer s'est arrêté sur une erreur avant de pouvoir rendre la caméra, donc cherche une erreur rouge venant de lui dans Output. Un autre script qui remet sans cesse CameraType sur Scriptable, comme une caméra de menu encore liée, peut aussi garder la caméra.
Le faire avec RoCode
Si tu préfères ne pas tout câbler à la main, RoCode peut le construire dans le jeu que tu as ouvert. RoCode est un agent IA indépendant pour Roblox Studio, qui n'est pas fait par Roblox : tu décris la fonctionnalité dans son chat web, et son plugin pour Studio crée la part et les scripts dans ton Explorer, donc tu ne copies pas de code depuis une fenêtre de chat.
Ajoute une cinématique d'intro : un dossier Cutscenes avec un dossier Intro de plans nommés 1 à 3, des sous-titres tirés d'un attribut Caption, des bandes noires et un bouton Skip, jouée une fois à la première apparition d'un joueur, avec le serveur qui immobilise le joueur et la caméra rendue à la fin.
- Peut d'abord vérifier ton jeu avec Search Scripts, par exemple pour trouver un script de menu ou de caméra qui règle déjà
CameraType, pour que les deux ne se battent pas - Crée les dossiers et la part déclencheur avec Create Instance, et règle sur les parts des attributs comme Caption et MoveSeconds
- Écrit CutsceneService et CutscenePlayer avec Create Script
- A pour consigne de vérifier chaque script qu'il écrit avec Check Script, qui le compile dans Studio sans le lancer, et place un point d'annulation avant et après chaque lot de changements
Place toi-même les parts de plan en faisant voler la caméra de Studio jusqu'à chaque vue, puis demande les scripts. Avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.11 ou plus récent il peut contrôler un personnage de test pour vérifier que le jeu marche, mais il ne prend pas de captures d'écran pendant que le jeu tourne, donc regarde la cinématique toi-même. Pour l'ordre dans lequel construire un jeu entier, vois faire un jeu Roblox avec l'IA, système par système. Comment RoCode se connecte à Studio.
Questions fréquentes
Comment faire jouer une cinématique quand un joueur rejoint le jeu ?
Nomme un dossier de plans Intro dans Workspace.Cutscenes, ou change INTRO_CUTSCENE pour le nom de ton dossier. CutsceneService le joue à la première apparition de chaque joueur sur un serveur. Pour ne le montrer qu'à la toute première visite de quelqu'un, sauvegarde un drapeau dans un data store et règle-le seulement une fois l'intro démarrée, comme expliqué dans Aller plus loin.
Peut-on faire une cinématique sans plugin ?
Oui. Ce guide n'utilise que des parts, des attributs et deux scripts, et la ligne de la Command Bar place chaque plan exactement là où se trouve la caméra de Studio. Des plugins comme Moon Animator restent pratiques pour animer les personnages qui jouent dans la cinématique.
Pourquoi ma caméra ne bouge pas dans ma cinématique ?
En général, le code de la caméra est dans un Script serveur, alors que seul un LocalScript peut déplacer la caméra d'un joueur, parce que chaque appareil a la sienne. L'autre cause fréquente : CameraType n'est pas Scriptable, donc les scripts de caméra par défaut de Roblox ramènent sans cesse la caméra vers le personnage.
Comment empêcher le joueur de bouger pendant une cinématique ?
Ancre son HumanoidRootPart sur le serveur pendant qu'elle joue et désancre-le ensuite, comme le fait CutsceneService. Une part ancrée ne bouge jamais à cause de la physique. WalkSpeed n'est pas touché, donc ça n'entre pas en conflit avec un script de sprint ou un pass de vitesse.
Comment ajouter un bouton Skip à une cinématique ?
Mets un TextButton sur l'écran de la cinématique et connecte son événement Activated, qui se déclenche pour un clic, un toucher, ou le bouton A d'une manette une fois le bouton sélectionné. Le Skip de CutscenePlayer règle un drapeau que la boucle des plans vérifie à chaque image, est sélectionné automatiquement pour les joueurs à la manette, et se trouve dans son propre ScreenGui avec les marges par défaut pour que l'encoche de caméra d'un téléphone ne puisse pas le couvrir. Le joystick et le bouton de saut sont cachés pendant la cinématique, donc ils ne sont pas à côté.
Pourquoi le monde est vide dans ma cinématique ?
Avec l'instance streaming activé, l'appareil d'un joueur n'a que la zone proche de son personnage. Fais appeler player:RequestStreamAroundAsync par le serveur pour chaque plan peu avant que la caméra y arrive, comme le fait CutsceneService. Roblox dit que ça rend le chargement de la zone probable, pas certain, donc garde les plans importants dans ton rayon de streaming, ou utilise Player:AddReplicationFocus pour une zone qui doit rester chargée.
Sources et lectures
- Roblox Creator Docs : Customize the camera (en anglais). la Camera propre à chaque client, Scriptable, CFrame et Focus
- Roblox Engine API : Camera (en anglais). CameraType, CameraSubject, Focus à chaque image, et Interpolate obsolète
- Roblox Creator Docs : Control the user's camera (en anglais). BindToRenderStep un cran de priorité après la caméra
- Roblox Engine API : TweenService:GetValue (en anglais). l'alpha avec easing, limité entre 0 et 1
- Roblox Engine API : ScreenGui.ScreenInsets (en anglais). pourquoi None est réservé au contenu sur lequel on n'appuie pas
- Roblox Creator Docs : Instance streaming (en anglais). activé par défaut dans les nouveaux jeux, et le focus de réplication
- Roblox Creator Docs : Streaming techniques (en anglais). précharger une zone avant de déclencher un événement
- Roblox Engine API : Player:RequestStreamAroundAsync (en anglais). une demande temporaire sans garantie
- Roblox Creator Docs : Remote events and callbacks (en anglais). les messages en file d'attente et les tables qu'on peut envoyer
- Roblox Creator Docs : Network ownership, movement validation, and physics (en anglais). ce qu'un client peut faire avec son propre personnage, y compris manipuler les événements Touched
- Roblox Engine API : Animator:LoadAnimation (en anglais). quelles animations sont répliquées
Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 14 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.