Tutoriel · Systèmes de jeu

Comment faire une cinématique sur Roblox Studio

Une cinématique (cutscene) sur Roblox, c'est la caméra qui prend la main pendant quelques secondes : elle coupe ou glisse d'un plan à l'autre, affiche un sous-titre, puis rend le contrôle. Ce guide en construit une que tu prépares en plaçant des parts invisibles là où la caméra doit être, sans plugin. Le serveur décide quand un joueur la voit (à sa première apparition, ou quand il touche un déclencheur), et l'appareil du joueur déplace la caméra, affiche des bandes noires et un bouton Skip, puis rend la caméra.

Mis à jour le 14 novembre 202625 min de lectureÉcrit par

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:Interpolate est obsolète (deprecated). La référence de Roblox dit d'animer la caméra avec TweenService à la place.
Sur cette page
  1. Fonctionnement
  2. 1. Placer les plans
  3. 2. Script serveur
  4. 3. LocalScript
  5. 4. Déclencheur
  6. Détails caméra
  7. Anciens tutoriels
  8. Limites des exploits
  9. 5. Tester
  10. Aller plus loin
  11. Problèmes courants
  12. Avec RoCode
  13. Questions fréquentes
  14. Sources et lectures

Comment marche une cinématique

Illustration animéeUne intro de deux plans en temps réel : une coupe sur le premier plan, 1 seconde de pause, 2,5 secondes de glissement jusqu'au pont, 1 seconde de pause, puis la caméra revient au joueur.

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 :

  1. 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.
  2. 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 CutsceneEvent pour ce joueur seulement, avec un id et la liste des plans.
  3. 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.
  4. Quand le dernier plan se termine, ou que le joueur appuie sur Skip, il rend la caméra au personnage et déclenche CutsceneEvent vers le serveur avec le même id.
  5. 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.
Les éléments du système de cinématique
ÉlémentOù il se trouveCe qu'il fait
Le Script CutsceneServiceServerScriptServiceDécide qui voit quelle cinématique et quand, lit les plans, immobilise le joueur et retient qui a vu quoi.
Le LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsJoue 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 CutsceneEventReplicatedStorage (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 CutscenesWorkspaceUn dossier par cinématique, comme Intro, qui contient les parts de plan nommées 1, 2, 3.
Le dossier CutsceneTriggersWorkspace (facultatif)Des parts qui lancent une cinématique quand un joueur les touche.
L'Explorer une fois le système de cinématique terminé. Le dossier Bridge et CutsceneTriggers arrivent à l'étape 4. CutsceneService ajoute un RemoteEvent nommé CutsceneEvent à ReplicatedStorage quand le jeu tourne.
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.

  1. 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.
  2. Fais voler la caméra de Studio jusqu'à la première vue que tu veux, comme si tu cadrais une photo.
  3. Insère une Part dans Intro et renomme-la 1.
  4. 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, CurrentCamera est 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.
  5. 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.
  6. Recommence pour les vues suivantes, en nommant les parts 2, 3 et 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.

Attributs facultatifs sur chaque part de plan
AttributTypePar défautCe qu'il fait
MoveSecondsnumber3Secondes 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.
HoldSecondsnumber1Secondes pendant lesquelles la caméra reste sur ce plan après y être arrivée.
CaptionstringaucunTexte 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
-- 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.

Les réglages en haut de CutsceneService
RéglageValeur iciCe 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_SECONDS3La durée d'un glissement quand un plan n'a pas d'attribut MoveSeconds.
DEFAULT_HOLD_SECONDS1Le temps que la caméra reste sur un plan qui n'a pas d'attribut HoldSeconds.
MAX_SHOTS30Le 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. readShots rassemble 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. play ne 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.delay libè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 seen retient, 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. playOnce ne 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

  1. Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts et insère un LocalScript nommé CutscenePlayer.
  2. Remplace son contenu par le code ci-dessous.
LocalScript dans StarterPlayerScripts nommé CutscenePlayer
-- 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.

Ce que fait chaque partie de CutscenePlayer
PartieCe qu'elle fait
Le ScreenGui CutsceneDeux 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 CutsceneControlsContient 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_GUISCache 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é.
TouchControlsEnabledSur 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.
updateCameraTourne à 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.
waitOrSkipAttend le temps de mouvement et de pause d'un plan, en vérifiant le drapeau Skip à chaque image.
playRend 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 SkipActivated 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.

  1. Dans Workspace, Cutscenes, insère un Folder nommé Bridge et place ses plans comme à l'étape 1, nommés 1 et 2. Dans la ligne de la Command Bar, utilise Bridge au lieu de Intro.
  2. Survole Workspace et insère un Folder nommé CutsceneTriggers.
  3. 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.
  4. Ajoute-lui un attribut nommé Cutscene, de type string, et mets sa valeur sur Bridge : 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é.

Styles d'easing adaptés à un mouvement de caméra
EASING_STYLERessenti 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.QuadComme Sine, avec une courbe un peu plus marquée.
Enum.EasingStyle.LinearVitesse 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.

Méthodes courantes des tutoriels de cinématique, et ce que ce guide fait à la place
Le tutorielLe problèmeCe 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'autreFocus 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éraLe 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 LocalScriptRien 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 clientAvec 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.

Ce qu'un tricheur peut tenter, et ce qui se passe
Un tricheur essaie deRésultat
Passer une cinématique, ou ne jamais la jouerAutorisé : c'est son propre écran. Ne donne jamais de récompense pour "a fini la cinématique".
Déclencher CutsceneEvent avec n'importe quelle valeurSeul 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 cartePossible : 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ématiqueRien à 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'autreImpossible. 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

  1. 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 2 MoveSeconds 2.5 et la Caption "Find the bridge", et laisse le plan 3 sans attributs.
  2. 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.
  3. 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.
  4. Marche dans BridgeTrigger : la cinématique Bridge se joue. Retraverse-le : rien ne se passe.
  5. 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.
  6. Laisse Workspace.StreamingEnabled activé 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).
  7. 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.
  8. 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.

Tu écris

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.

RoCode fait
  • 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

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.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.