Tutoriel · Systèmes de jeu

Comment faire un système de manches sur Roblox Studio

La plupart des jeux Roblox à manches tournent sur la même boucle : attendre des joueurs, faire un compte à rebours, charger une carte, téléporter tout le monde dedans, lancer un timer, désigner un gagnant et tout ranger. Ce guide construit cette boucle dans un seul script serveur facile à lire, ajoute un timer que chaque joueur voit, et gère les cas qui cassent les scripts copiés : les joueurs qui meurent, partent ou arrivent en pleine manche.

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

En bref

Écris un seul Script serveur dans ServerScriptService qui passe en boucle par une série fixe d'états : intermission (attendre assez de joueurs, puis compte à rebours), chargement de la carte (cloner une carte au hasard de ServerStorage dans Workspace), téléportation (placer chaque personnage vivant sur une part de spawn avec PivotTo), manche (faire tourner un timer jusqu'à la fin du temps ou jusqu'à ce qu'il ne reste qu'un joueur ou une équipe) et nettoyage (donner les Wins, faire réapparaître les survivants, détruire la carte).

  • Fais tourner la boucle uniquement sur le serveur. Publie le statut et les secondes restantes sous forme d'attributs sur un Folder dans ReplicatedStorage, et laisse un LocalScript les afficher.
  • Garde une table de qui est encore dans la manche. Retire un joueur quand son Humanoid meurt, que son personnage est supprimé ou qu'il quitte le jeu.
  • Ne téléporte que les joueurs dont le personnage est vivant au début de la manche. Ceux qui arrivent après attendent dans le lobby la manche suivante.
Sur cette page
  1. Fonctionnement
  2. 1. Lobby et cartes
  3. 2. Script de manche
  4. Chaque état
  5. 3. Interface du timer
  6. Joueurs en pleine manche
  7. Aller plus loin
  8. Problèmes courants
  9. Avec RoCode
  10. Questions fréquentes
  11. Sources et lectures

Comment marche un système de manches

Illustration animéeLes scripts de manche terminés dans un jeu en cours, en accéléré.

Un système de manches est une machine à états. À tout moment, le serveur est dans un seul état, chaque état a une seule tâche, et une condition le fait passer au suivant. Écrit comme ça, la logique reste au même endroit, ce qui évite le bug classique où une boucle de timer et une boucle de manche essaient toutes les deux de terminer la même manche.

Les états de la boucle de manche de ce guide
ÉtatCe que fait le serveurPasse au suivant quand
WaitingAffiche "Waiting for players (1/2)"Il y a assez de joueurs sur le serveur
IntermissionFait le compte à rebours pendant que tout le monde est dans le lobbyLe compte à rebours se termine (ou retour à Waiting si des joueurs partent)
StartingCopie une carte au hasard dans Workspace, affiche son nom, demande aux clients de la chargerUn court compte à rebours "préparez-vous" se termine
InRoundTéléporte les joueurs vivants, fait tourner le timer, retire les joueurs qui meurent ou partentLe temps est écoulé, ou il ne reste qu'un joueur ou une équipe
ResultsDonne un Win à tous ceux qui sont encore vivants et affiche qui a gagnéQuelques secondes ont passé
CleanupFait réapparaître les survivants dans le lobby et détruit la carteTout de suite, puis la boucle recommence

Le serveur possède chaque état. Les clients affichent seulement ce que le serveur leur dit. Un compte à rebours qui tourne dans un LocalScript dérive par rapport au vrai, est faux pour les joueurs qui arrivent en retard, et peut être modifié par un exploiteur. Si la séparation entre serveur et client est nouvelle pour toi, lis d'abord Script vs LocalScript vs ModuleScript (en anglais).

Étape 1 : construire le lobby, les cartes et la stat Wins

  1. Construis un lobby dans Workspace avec une SpawnLocation. Vérifie que sa propriété Neutral est cochée, pour que chaque joueur apparaisse ici, attende ici et revienne ici après avoir été éliminé.
  2. Dans ServerStorage, insère un Folder nommé Maps. Les objets de ServerStorage ne sont jamais envoyés aux joueurs, donc les cartes inutilisées ne leur coûtent rien.
  3. Construis chaque carte comme un Model dans Maps, avec ses parts ancrées (Anchored). Construis-la loin du lobby (quelques centaines de studs suffisent), parce que la copie apparaît exactement là où tu l'as construite et que les joueurs éliminés ne doivent pas pouvoir y revenir à pied.
  4. Dans chaque carte, ajoute un Folder nommé Spawns avec une Part ancrée pour chaque joueur que tu prévois. Règle leur Transparency sur 1 et désactive CanCollide pour que personne ne les voie ni ne trébuche dessus.
L'Explorer à la fin de ce guide
Workspace
  Lobby Model
    SpawnLocation SpawnLocation
ServerStorage
  Maps Folder new
    Desert Model new
      Spawns Folder new
        Spawn1 Part new
        Spawn2 Part new
    Castle Model new
      Spawns Folder new
ServerScriptService
  Leaderstats Script new
  RoundSystem Script new
StarterGui
  RoundHud ScreenGui new
    RoundHudClient LocalScript new

Le script de manche ajoute 1 à une IntValue nommée Wins dans le dossier leaderstats du joueur. Si ton jeu n'a pas encore de leaderstats, ajoute ce petit script. Si tu en as déjà un, par exemple la version avec sauvegarde du guide du leaderboard, saute-le : deux scripts qui créent des leaderstats donnent deux dossiers à chaque joueur.

Script dans ServerScriptService nommé Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- doit avoir exactement ce nom, tout en minuscules

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Dans Studio tu peux rejoindre avant que ce script tourne, donc on prépare aussi ceux qui sont déjà là
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Ces Wins repartent à zéro quand le joueur quitte le jeu. Pour les garder d'une session à l'autre, utilise la version avec data store du guide du leaderboard.

Étape 2 : ajouter le script de manche

Insère un Script dans ServerScriptService, nomme-le RoundSystem et colle le code ci-dessous. Les réglages en haut sont les seules lignes que tu devrais avoir à changer. Chaque état est une fonction à part, et la boucle tout en bas les lance dans l'ordre, sans fin.

Script dans ServerScriptService nommé RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Réglages
local MIN_PLAYERS = 2 -- mets 1 pendant que tu testes seul
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true : la manche se termine quand une seule équipe a encore des joueurs

local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()

-- Ce que l'écran de chaque joueur affiche est rangé dans des attributs sur ce dossier.
-- Les attributs réglés par le serveur sont répliqués à tous les clients, même ceux qui arrivent en retard.
local roundInfo = Instance.new("Folder")
roundInfo.Name = "RoundInfo"
roundInfo.Parent = ReplicatedStorage

local function setState(state: string, status: string)
	roundInfo:SetAttribute("State", state)
	roundInfo:SetAttribute("Status", status)
	roundInfo:SetAttribute("TimeLeft", 0)
end

local function setTimeLeft(seconds: number)
	roundInfo:SetAttribute("TimeLeft", seconds)
end

-- Qui est encore dans la manche en cours, et les connexions qui surveillent chacun
local alive: { [Player]: boolean } = {}
local watchers: { [Player]: { RBXScriptConnection } } = {}

local function eliminate(player: Player)
	if not alive[player] then
		return
	end
	alive[player] = nil
	player:SetAttribute("InRound", false)
	local connections = watchers[player]
	if connections then
		for _, connection in connections do
			connection:Disconnect()
		end
		watchers[player] = nil
	end
end

Players.PlayerRemoving:Connect(eliminate)

-- Renvoie le personnage et l'humanoid seulement si le joueur est vivant en ce moment
local function getLivingCharacter(player: Player): (Model?, Humanoid?)
	local character = player.Character
	if not character or not character.Parent then
		return nil, nil
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or not humanoid.RootPart then
		return nil, nil
	end
	return character, humanoid
end

-- Compte les camps encore dans la manche (des joueurs, ou des équipes quand USE_TEAMS est activé)
local function countSides(): (number, number)
	local sides: { [Instance]: boolean } = {}
	local sideCount = 0
	local playerCount = 0
	for player in alive do
		playerCount += 1
		local team = player.Team
		local side: Instance = if USE_TEAMS and team then team else player
		if not sides[side] then
			sides[side] = true
			sideCount += 1
		end
	end
	return sideCount, playerCount
end

-- ÉTAT : Waiting et Intermission. Renvoie false si des joueurs sont partis pendant le compte à rebours.
local function runIntermission(): boolean
	while #Players:GetPlayers() < MIN_PLAYERS do
		setState("Waiting", `Waiting for players ({#Players:GetPlayers()}/{MIN_PLAYERS})`)
		task.wait(1)
	end
	setState("Intermission", "Intermission")
	for secondsLeft = INTERMISSION_SECONDS, 1, -1 do
		if #Players:GetPlayers() < MIN_PLAYERS then
			return false
		end
		setTimeLeft(secondsLeft)
		task.wait(1)
	end
	return true
end

-- ÉTAT : Starting, partie 1. Copier une carte au hasard (pas la dernière, s'il y a le choix).
local lastMapName = ""

local function loadMap(): Model?
	local allMaps: { Model } = {}
	local freshMaps: { Model } = {}
	for _, child in mapsFolder:GetChildren() do
		if child:IsA("Model") then
			table.insert(allMaps, child)
			if child.Name ~= lastMapName then
				table.insert(freshMaps, child)
			end
		end
	end
	local choices = if #freshMaps > 0 then freshMaps else allMaps
	if #choices == 0 then
		warn("RoundSystem: add at least one map Model to ServerStorage > Maps")
		return nil
	end
	local chosen = choices[random:NextInteger(1, #choices)]
	lastMapName = chosen.Name
	local map = chosen:Clone()
	map.Parent = workspace
	return map
end

local function getSpawnPoints(map: Model): { BasePart }
	local points: { BasePart } = {}
	local folder = map:FindFirstChild("Spawns")
	if folder then
		for _, child in folder:GetChildren() do
			if child:IsA("BasePart") then
				table.insert(points, child)
			end
		end
	end
	-- Mélanger, pour que les joueurs n'arrivent pas au même spawn à chaque manche
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- La hauteur de la part racine d'un personnage debout au-dessus du sol.
-- La formule vient de la référence Humanoid.HipHeight de Roblox (les rigs R6 ajoutent la hauteur de la jambe).
local function rootHeight(character: Model, humanoid: Humanoid, rootPart: BasePart): number
	local height = rootPart.Size.Y / 2 + humanoid.HipHeight
	if humanoid.RigType == Enum.HumanoidRigType.R6 then
		local leg = character:FindFirstChild("Left Leg")
		if leg and leg:IsA("BasePart") then
			height += leg.Size.Y
		end
	end
	return height
end

-- ÉTAT : Starting, partie 2. Se préparer, puis téléporter tous ceux qui sont vivants.
local function startRound(map: Model): boolean
	local spawnPoints = getSpawnPoints(map)
	if #spawnPoints == 0 then
		warn(`RoundSystem: {map.Name} needs a Spawns folder with at least one part in it`)
		return false
	end

	-- Avec le streaming activé, demander à chaque client de charger la carte avant que son personnage arrive
	if workspace.StreamingEnabled then
		local mapPosition = map:GetPivot().Position
		for _, player in Players:GetPlayers() do
			task.spawn(function()
				pcall(function()
					player:RequestStreamAroundAsync(mapPosition, GET_READY_SECONDS)
				end)
			end)
		end
	end

	setState("Starting", `Map: {map.Name}`)
	for secondsLeft = GET_READY_SECONDS, 1, -1 do
		setTimeLeft(secondsLeft)
		task.wait(1)
	end

	-- Seuls les joueurs vivants à cet instant participent. Les autres attendent la manche suivante.
	local participants: { Player } = {}
	for _, player in Players:GetPlayers() do
		if getLivingCharacter(player) then
			table.insert(participants, player)
		end
	end
	if #participants < MIN_PLAYERS then
		setState("Waiting", "Not enough players, starting over")
		task.wait(2)
		return false
	end

	for index, player in participants do
		local character, humanoid = getLivingCharacter(player)
		local rootPart = if humanoid then humanoid.RootPart else nil
		if character and humanoid and rootPart then
			local spawnPart = spawnPoints[(index - 1) % #spawnPoints + 1]
			-- Le pivot d'un personnage est sa part racine, donc on le monte à hauteur debout au-dessus de la part
			local height = spawnPart.Size.Y / 2 + rootHeight(character, humanoid, rootPart)
			character:PivotTo(spawnPart.CFrame + Vector3.new(0, height, 0))
			alive[player] = true
			player:SetAttribute("InRound", true)
			watchers[player] = {
				humanoid.Died:Connect(function()
					eliminate(player)
				end),
				player.CharacterRemoving:Connect(function()
					eliminate(player)
				end),
			}
		end
	end
	return true
end

-- ÉTAT : InRound. Se termine quand le temps est écoulé ou qu'il ne reste qu'un camp.
local function runRound()
	setState("InRound", "Round in progress")
	local startingSides = countSides()
	for secondsLeft = ROUND_SECONDS, 1, -1 do
		local _, playersLeft = countSides()
		roundInfo:SetAttribute("Status", `{playersLeft} left`)
		setTimeLeft(secondsLeft)
		task.wait(1)
		local sidesLeft = countSides()
		-- Une manche qui a commencé avec un seul camp (un test solo) ne se termine qu'au temps ou à la mort
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- ÉTAT : Results. Tous ceux qui sont encore vivants gagnent.
local function awardWin(player: Player)
	local leaderstats = player:FindFirstChild("leaderstats")
	local wins = leaderstats and leaderstats:FindFirstChild("Wins")
	if wins and wins:IsA("IntValue") then
		wins.Value += 1
	end
end

local function finishRound(): { Player }
	local sidesLeft = countSides()
	local winners: { Player } = {}
	for player in alive do
		table.insert(winners, player)
	end

	local message = `{#winners} players survived!`
	local firstTeam = if #winners > 0 then winners[1].Team else nil
	if #winners == 0 then
		message = "Nobody survived"
	elseif USE_TEAMS and sidesLeft == 1 and firstTeam then
		message = `{firstTeam.Name} wins!`
	elseif #winners == 1 then
		message = `{winners[1].DisplayName} wins!`
	end

	for _, player in winners do
		awardWin(player)
		eliminate(player) -- on arrête de les surveiller ; ils restent sur la carte jusqu'au nettoyage
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- ÉTAT : Cleanup. Renvoyer les survivants au lobby, puis supprimer la carte.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- toujours sur le serveur
			task.spawn(function()
				local ok, err = pcall(function()
					player:LoadCharacterAsync()
				end)
				if not ok then
					warn(`RoundSystem: could not respawn {player.Name}: {err}`)
				end
			end)
		end
	end
	map:Destroy()
end

-- La boucle : un tour égale une manche
while true do
	if runIntermission() then
		local map = loadMap()
		if map then
			local survivors: { Player } = {}
			if startRound(map) then
				runRound()
				survivors = finishRound()
			end
			cleanup(map, survivors)
		else
			task.wait(5) -- pas encore de carte : on réessaie bientôt
		end
	end
end

Tout ce qui compte se passe ici, sur le serveur : qui est dans la manche, le timer, le gagnant et les Wins. Les clients reçoivent seulement trois attributs sur ReplicatedStorage.RoundInfo (State, Status et TimeLeft) et un attribut InRound sur chaque joueur.

Comment marche chaque état

Attente et intermission

runIntermission bloque d'abord la boucle jusqu'à ce que #Players:GetPlayers() atteigne MIN_PLAYERS. Ensuite il décompte seconde par seconde avec task.wait(1), en vérifiant le nombre de joueurs à chaque tick. Si quelqu'un part et que le serveur passe sous le minimum, il renvoie false et la boucle principale recommence à Waiting, donc une manche ne démarre jamais avec une seule personne.

Choisir et charger une carte

loadMap rassemble chaque Model de ServerStorage.Maps, écarte celui de la manche précédente s'il y en a un autre à choisir, et en prend un avec Random:NextInteger. Il clone ensuite la carte dans Workspace. L'original reste intact dans ServerStorage, donc chaque manche part d'une copie neuve : tout ce que les joueurs ont cassé ou déplacé à la manche précédente a disparu.

Les nouveaux emplacements (places) ont le streaming d'instances activé, ce qui veut dire qu'un client n'a que les parts proches de son personnage. Avant la téléportation, le script appelle Player:RequestStreamAroundAsync pour chaque joueur, ce qui demande au moteur d'envoyer à ce client la zone autour de la carte pendant le compte à rebours "préparez-vous". Sans ça, les joueurs peuvent arriver avant que le sol soit chargé et rester bloqués un instant.

Téléporter les joueurs avec PivotTo

Après le compte à rebours, le script fait la liste des participants à partir des joueurs dont le personnage existe, est toujours dans le monde et a un Humanoid avec plus de 0 de vie et une part racine. Cette vérification a lieu après le compte à rebours, donc quelqu'un qui est mort ou parti pendant ce temps n'est pas inclus.

Chaque participant est déplacé avec character:PivotTo(cframe). La référence de Roblox présente PivotTo comme la façon principale de déplacer des modèles depuis un script, et elle déplace toutes les parts du personnage ensemble. Régler HumanoidRootPart.Position n'est pas pareil : Roblox ajuste les articulations pour que cette seule part bouge, ce qui peut laisser le reste du corps derrière. Le pivot d'un personnage est sa part racine, donc la cible est le CFrame de la part de spawn, monté de la moitié de la hauteur de la part plus la hauteur à laquelle la part racine se tient au-dessus du sol. rootHeight calcule ça avec la formule de la référence Humanoid.HipHeight de Roblox : la moitié de la hauteur de la part racine plus HipHeight, plus la longueur de la jambe sur les rigs R6. Comme ça, les avatars redimensionnés ou personnalisés n'atterrissent pas dans la part et ne tombent pas dessus. Comme le CFrame contient aussi la rotation, les joueurs regardent dans la direction de la part de spawn, donc tourne les parts pour que tout le monde regarde vers le centre de la carte.

S'il y a plus de joueurs que de parts de spawn, le script revient à la première part et des joueurs atterrissent les uns sur les autres, donc ajoute au moins autant de spawns que ton nombre maximum de joueurs.

Si tu utilises aussi la vérification de vitesse du guide du script de sprint, ajoute player:SetAttribute("MovementCheckSkip", true) juste après character:PivotTo(...) dans startRound, pour que la téléportation ne soit pas signalée comme un excès de vitesse.

Le timer de manche et les conditions de fin

runRound avance une fois par seconde. À chaque tick, il met à jour le statut (combien de joueurs restent) et les secondes restantes, puis compte les camps encore vivants. La manche se termine de l'une de ces trois façons :

  • Le temps est écoulé. La boucle for arrive à 1 et se termine.
  • Il ne reste qu'un camp. Un camp est un joueur, ou une équipe quand USE_TEAMS est activé. La vérification ne compte que si la manche a commencé avec deux camps ou plus, pour qu'un test en solo ne se termine pas au moment où il commence.
  • Il ne reste personne. Tout le monde est mort ou parti, donc la manche se termine sans gagnant.

Comme la vérification se fait une fois par seconde, une manche peut durer jusqu'à une seconde après la dernière élimination, ce qui se remarque rarement sur un timer de manche.

Donner les Wins et afficher le résultat

La règle de ce script est simple : tous ceux qui sont encore vivants à la fin de la manche gagnent. Ça couvre le dernier joueur debout, la dernière équipe debout et "survivre jusqu'à la fin du timer" avec une seule ligne de logique. finishRound ajoute 1 aux Wins de chaque gagnant, arrête de les surveiller et affiche un message comme "Alex wins!" pendant RESULTS_SECONDS. Si tu veux qu'une fin de temps n'ait pas de gagnant, saute awardWin et change le message quand sidesLeft est supérieur à 1. Renvoie la liste dans tous les cas, parce que le nettoyage s'en sert pour ramener les survivants au lobby.

Nettoyage

Les survivants sont encore debout sur la carte, donc cleanup les fait réapparaître dans le lobby avec Player:LoadCharacterAsync(), qui remplace l'ancien LoadCharacter, puis détruit la copie de la carte. Chaque réapparition tourne dans son propre task.spawn à l'intérieur d'un pcall, parce que l'appel attend que le personnage soit chargé et peut échouer si le joueur part à ce moment-là. Les joueurs éliminés n'ont besoin de rien : ils sont déjà réapparus tout seuls dans le lobby.

Étape 3 : afficher le timer et le statut à chaque joueur

Le serveur publie trois attributs sur ReplicatedStorage.RoundInfo : State (un mot fixe comme InRound, pour les scripts), Status (du texte pour les humains) et TimeLeft (des secondes). Les attributs qu'un script serveur règle sur un objet répliqué arrivent automatiquement chez chaque client, et un joueur qui arrive en pleine manche reçoit tout de suite les valeurs actuelles. C'est pour ça que c'est mieux qu'un RemoteEvent pour un timer : un RemoteEvent déclenché avant l'arrivée de quelqu'un ne l'atteint jamais.

  1. Dans l'Explorer, insère une ScreenGui dans StarterGui et nomme-la RoundHud. Laisse ResetOnSpawn activé (la valeur par défaut).
  2. Insère un LocalScript dans RoundHud, nomme-le RoundHudClient et colle le code ci-dessous. Il construit le label lui-même, donc il n'y a rien d'autre à dessiner.
  3. Appuie sur Play. Le label en haut de l'écran affiche le statut et un compte à rebours au format m:ss.
LocalScript dans la ScreenGui RoundHud dans StarterGui nommé RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui

-- Le label. Si tu as dessiné ton propre TextLabel dans RoundHud, supprime ce bloc et utilise :
-- local label = screenGui:WaitForChild("StatusLabel") :: TextLabel
local label = Instance.new("TextLabel")
label.Name = "StatusLabel"
label.AnchorPoint = Vector2.new(0.5, 0)
label.Position = UDim2.new(0.5, 0, 0, 12)
label.Size = UDim2.fromOffset(320, 44)
label.BackgroundColor3 = Color3.fromRGB(20, 14, 32)
label.BackgroundTransparency = 0.2
label.TextColor3 = Color3.new(1, 1, 1)
label.Font = Enum.Font.BuilderSansBold
label.TextSize = 22
label.TextWrapped = true -- les messages plus longs passent sur une deuxième ligne
label.Text = ""
label.Parent = screenGui

local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 10)
corner.Parent = label

local function formatTime(seconds: number): string
	return string.format("%d:%02d", seconds // 60, seconds % 60)
end

local function update()
	local status = roundInfo:GetAttribute("Status")
	local timeLeft = roundInfo:GetAttribute("TimeLeft")
	local text = if type(status) == "string" then status else ""
	if type(timeLeft) == "number" and timeLeft > 0 then
		text ..= "   " .. formatTime(timeLeft)
	end
	label.Text = text
end

roundInfo:GetAttributeChangedSignal("Status"):Connect(update)
roundInfo:GetAttributeChangedSignal("TimeLeft"):Connect(update)
update()

Comme ResetOnSpawn est activé, Roblox donne au joueur une nouvelle copie de RoundHud à chaque apparition de son personnage, y compris la réapparition du nettoyage. Le script relit alors les attributs actuels, donc le label n'est jamais en retard.

Le client ne fait que lire. Rien de ce qu'un joueur change sur son propre écran n'affecte le vrai timer, parce que les changements d'attributs faits par un LocalScript restent sur ce seul client. Pour un compte à rebours qui affiche les dixièmes de seconde, le serveur peut plutôt stocker une heure de fin tirée de workspace:GetServerTimeNow() dans un attribut, et chaque client soustrait son propre workspace:GetServerTimeNow() à chaque image.

Si ton jeu s'ouvre sur un menu principal, RoundHud apparaît quand le joueur appuie sur Play, parce que StarterGui n'est copié chez un joueur qu'une fois que son personnage apparaît. Les joueurs encore dans le menu n'ont pas de personnage, donc ils ne sont jamais téléportés dans une manche.

Les joueurs qui meurent, partent ou arrivent en pleine manche

Ces cas sont faciles à oublier quand on écrit un script de manche pour la première fois. Quand l'un d'eux n'est pas géré, tu vois en général une erreur dans l'Output ou une manche qui ne se termine jamais. Voici ce que fait le script ci-dessus avec chacun.

Les cas particuliers et comment le script de manche les gère
SituationCe qui se passeOù dans le script
Un joueur meurt pendant la manche (tué, reset, tombé)Il est retiré de la manche et réapparaît dans le lobby après Players.RespawnTime (5 secondes par défaut).humanoid.Died appelle eliminate
Un personnage est supprimé sans mourirComme une mort : il est éliminé.player.CharacterRemoving appelle eliminate
Un joueur quitte le serveurIl est retiré, ses connexions sont coupées, et le tick suivant recompte les camps.Players.PlayerRemoving appelle eliminate
Un joueur arrive en pleine mancheIl apparaît dans le lobby, voit le statut et le timer en direct, et rejoint la manche suivante.Les participants ne sont choisis que dans startRound
Un joueur était mort au début de la mancheIl n'est pas téléporté et attend dans le lobby.getLivingCharacter
Tout le monde part ou meurtLa manche se termine sur "Nobody survived" et la boucle recommence : Intermission s'il reste assez de joueurs sur le serveur, Waiting sinon.sidesLeft == 0 dans runRound

eliminate est écrit pour pouvoir être appelé sans risque plusieurs fois pour le même joueur. Un joueur qui meurt puis réapparaît déclenche à la fois Died et CharacterRemoving, et un joueur qui part peut déclencher les trois événements ; seul le premier appel fait quelque chose.

Aller plus loin : équipes, vote de carte et événements de manche

Dernière équipe debout

Mets USE_TEAMS = true, puis ajoute des objets Team sous le service Teams dans l'Explorer, chacun avec son nom et sa TeamColor. Par défaut, Roblox met chaque joueur qui arrive dans l'équipe auto-assignable qui a le moins de membres. Il ne rééquilibre pas quand des joueurs partent, donc des équipes inégales peuvent arriver dans les longues sessions. Garde la SpawnLocation du lobby en Neutral pour que toutes les équipes y apparaissent. La manche se termine alors quand une seule équipe a encore des joueurs vivants, et le résultat affiche "Red wins!".

Pour un format un contre tous (un chasseur, tous les autres survivent), choisis un participant au hasard dans startRound et règle son Team sur une équipe de chasseurs avant la téléportation. Décoche AutoAssignable sur l'équipe des chasseurs pour que les nouveaux joueurs n'y soient jamais mis, et remets le chasseur dans l'équipe des survivants dans cleanup. Les mêmes conditions de fin marchent alors : le chasseur gagne si tous les survivants sont éliminés, et les survivants gagnent s'ils tiennent jusqu'à la fin du timer, à condition de sauter l'awardWin du chasseur quand le temps est écoulé.

Laisser les joueurs voter pour une carte

Un vote demande au client de parler au serveur, donc il faut un RemoteEvent. Pendant l'intermission, le serveur publie deux ou trois noms de cartes sous forme d'attributs, chaque client déclenche le RemoteEvent avec le nom sur lequel il a cliqué, et le serveur compte les votes avant que loadMap tourne. Le serveur doit vérifier chaque vote : que l'argument est une chaîne, que c'est une des options du moment, que l'état est Intermission, et que chaque joueur ne compte qu'une fois (range les votes dans une table indexée par Player, pour qu'un deuxième vote remplace le premier, et vide-la sur PlayerRemoving). Le guide des RemoteEvents couvre ce modèle de validation en entier.

Donner un outil aux joueurs au début de la manche

D'autres scripts peuvent réagir à la manche sans toucher à RoundSystem. Le script de manche règle un attribut InRound sur chaque joueur quand il est téléporté et l'efface quand il est éliminé. Ce script l'écoute et donne à chaque joueur une copie d'un Tool nommé RoundTool rangé dans ServerStorage.

Script dans ServerScriptService nommé GiveRoundTool
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

local toolTemplate = ServerStorage:WaitForChild("RoundTool") :: Tool

local function watchPlayer(player: Player)
	player:GetAttributeChangedSignal("InRound"):Connect(function()
		if player:GetAttribute("InRound") ~= true then
			return
		end
		local backpack = player:FindFirstChildOfClass("Backpack")
		if backpack then
			toolTemplate:Clone().Parent = backpack
		end
	end)
end

Players.PlayerAdded:Connect(watchPlayer)
for _, player in Players:GetPlayers() do
	watchPlayer(player)
end

Il n'y a pas de code pour reprendre l'outil. Quand un personnage meurt, Roblox remplace le Backpack par un nouveau rempli depuis StarterPack, et LoadCharacterAsync au nettoyage le vide pour les survivants, donc l'outil a disparu quand la manche est finie.

Pour une arme à distribuer, construis l'épée ou le pistolet à raycast (en anglais), range-la dans ServerStorage au lieu de StarterPack, et remplace "RoundTool" dans ce script par son nom.

PNJ et autres objets réservés à la manche

Tout ce qui ne doit exister que pendant une manche peut vivre dans le modèle de la carte : des ennemis, des objets à ramasser, des plateformes mobiles. Les scripts dans un modèle de ServerStorage ne tournent pas ; une fois la copie dans Workspace, ils démarrent, et map:Destroy() au nettoyage les supprime avec tout le reste. Pour ajouter des ennemis qui poursuivent les joueurs, construis-en un avec le guide du pathfinding de PNJ et pose-le dans une carte. Pour un survol de la carte au début de chaque manche, le guide des cinématiques montre comment ce script peut lancer une cinématique pour chaque joueur avec un BindableEvent.

En faire un module

Tu n'as pas besoin d'un ModuleScript pour commencer. Un seul Script est plus facile à lire pendant que tu construis le jeu. Découpe-le quand d'autres scripts doivent appeler des fonctions de manche, ou quand tu veux les réglages dans un ModuleScript partagé que le serveur et ton interface peuvent tous les deux charger avec require. D'ici là, l'attribut State sur RoundInfo et l'attribut InRound sur chaque joueur servent déjà d'interface publique au système de manches : n'importe quel script peut les écouter.

Problèmes courants

Ouvre la fenêtre Output (depuis le menu Window ou l'onglet Script de Studio) avant d'appuyer sur Play. La plupart des problèmes de système de manches y affichent un avertissement ou une erreur, avec le nom du script et le numéro de ligne.

Bloqué sur "Waiting for players (1/2)"

Tu testes seul et MIN_PLAYERS vaut 2. Mets 1 pour les tests en solo, ou teste avec Server & Clients et 2 clients.

Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'

Le dossier manque, est mal écrit ou est dans le mauvais service. Ce doit être un Folder nommé exactement Maps directement dans ServerStorage. Le même avertissement pour RoundInfo dans un LocalScript veut dire que le script RoundSystem n'est jamais allé jusqu'à le créer : il est désactivé, il a planté, ou il attend encore le dossier Maps.

Les joueurs passent à travers la carte après la téléportation

Les parts de la carte ne sont pas ancrées, donc la copie s'effondre dès qu'elle est dans Workspace. Sélectionne la carte, ancre ses parts, et vérifie que les parts de spawn sont au-dessus du sol, pas dedans.

Les joueurs éliminés réapparaissent dans l'arène

Il y a une SpawnLocation dans une carte. Remplace-la par une Part simple dans le dossier Spawns de la carte.

La manche ne se termine jamais quand tout le monde est mort

Vérifie que tes dégâts tuent vraiment l'Humanoid (la vie arrive à 0) au lieu de déplacer ou d'ancrer les joueurs. Si tu as désactivé l'état Dead de l'humanoid, Died ne se déclenche jamais et la manche doit aller jusqu'au bout du timer.

La boucle de manche s'arrête pour de bon après une erreur

La boucle tourne dans un seul thread, donc une erreur dans n'importe quel état l'arrête. Lis l'erreur dans l'Output, corrige la ligne et reteste. Une cause fréquente est de modifier le script pour utiliser player.Character.Humanoid sans vérifier que le personnage existe.

Le faire avec RoCode

Si tu préfères ne pas assembler tout ça à la main, RoCode peut le construire dans le jeu que tu as ouvert. C'est un agent IA qui passe par un plugin Roblox Studio, donc les scripts et les parts apparaissent dans ton Explorer au lieu d'une fenêtre de chat d'où tu devrais les coller.

Tu écris

Ajoute un système de manches : une intermission de 20 secondes qui demande 2 joueurs, une carte au hasard de ServerStorage.Maps, téléporte tout le monde sur les parts de spawn de la carte, des manches de 2 minutes où le dernier joueur vivant gagne, ajoute un Win dans leaderstats, et affiche le statut et le timer en haut de l'écran.

RoCode fait
  • Peut d'abord parcourir ton jeu avec List Children, Search Game et Search Scripts, pour utiliser ton dossier Maps et ton script leaderstats existants au lieu d'en ajouter un deuxième jeu
  • Crée le Script de manche dans ServerScriptService et le LocalScript du timer avec Create Script, et peut poser une arène à partir de ses structures toutes prêtes avec Place Prefab si tu n'as pas encore de carte
  • Vérifie la compilation de chaque script dans Studio avec Check Script avant de terminer. Ça attrape les erreurs de syntaxe, pas la logique de manche
  • Après ton test, Check Output lit les lignes Server et Client de ton dernier test pour pouvoir corriger une erreur d'exécution

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, mais il ne teste pas à plusieurs joueurs, donc c'est toi qui lances les manches avec Server & Clients. Chaque lot de changements est un point d'annulation dans Studio. Une boucle de manche est le cœur de beaucoup de jeux, et faire un jeu Roblox entier avec l'IA, système par système part souvent d'une boucle comme celle-ci. Comment RoCode se connecte à Studio.

Questions fréquentes

Comment faire un système de manches avec des équipes ?

Ajoute des objets Team sous le service Teams et mets USE_TEAMS = true dans le script de manche. Roblox met les joueurs qui arrivent dans l'équipe auto-assignable qui a le moins de membres, et la manche se termine quand une seule équipe a encore des joueurs vivants.

Comment afficher un compte à rebours à tous les joueurs ?

Règle les secondes restantes comme attribut sur un objet de ReplicatedStorage depuis le serveur, et écoute-les avec GetAttributeChangedSignal dans un LocalScript qui met à jour un TextLabel, comme à l'étape 3. Les joueurs qui arrivent en retard reçoivent tout de suite la valeur actuelle.

Faut-il utiliser wait() ou task.wait() dans une boucle de manche ?

Utilise task.wait(). Roblox indique que le wait() global est déprécié et remplacé par task.wait().

Comment téléporter les joueurs vers un autre emplacement à chaque manche ?

C'est un autre outil. Ce guide déplace les personnages à l'intérieur d'un seul serveur avec PivotTo. Envoyer des joueurs vers un autre emplacement (place) de ton expérience passe par TeleportService, qui les envoie sur un autre serveur. Le guide du téléporteur construit des portails qui font ça, avec de nouvelles tentatives quand une téléportation échoue.

Pourquoi mes joueurs se figent un instant après la téléportation ?

Avec le streaming d'instances activé, le client n'a pas encore reçu la carte. L'appel à RequestStreamAroundAsync du script pendant le compte à rebours de préparation demande au moteur de l'envoyer en avance ; un GET_READY_SECONDS plus long laisse plus de temps aux connexions lentes.

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.