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
Comment marche un système de manches
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.
| État | Ce que fait le serveur | Passe au suivant quand |
|---|---|---|
| Waiting | Affiche "Waiting for players (1/2)" | Il y a assez de joueurs sur le serveur |
| Intermission | Fait le compte à rebours pendant que tout le monde est dans le lobby | Le compte à rebours se termine (ou retour à Waiting si des joueurs partent) |
| Starting | Copie une carte au hasard dans Workspace, affiche son nom, demande aux clients de la charger | Un court compte à rebours "préparez-vous" se termine |
| InRound | Téléporte les joueurs vivants, fait tourner le timer, retire les joueurs qui meurent ou partent | Le temps est écoulé, ou il ne reste qu'un joueur ou une équipe |
| Results | Donne un Win à tous ceux qui sont encore vivants et affiche qui a gagné | Quelques secondes ont passé |
| Cleanup | Fait réapparaître les survivants dans le lobby et détruit la carte | Tout 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
- 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é. - Dans ServerStorage, insère un
FoldernomméMaps. Les objets de ServerStorage ne sont jamais envoyés aux joueurs, donc les cartes inutilisées ne leur coûtent rien. - Construis chaque carte comme un
ModeldansMaps, 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. - Dans chaque carte, ajoute un
FoldernomméSpawnsavec unePartancré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.
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.
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.
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
forarrive à 1 et se termine. - Il ne reste qu'un camp. Un camp est un joueur, ou une équipe quand
USE_TEAMSest 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.
- Dans l'Explorer, insère une ScreenGui dans StarterGui et nomme-la
RoundHud. Laisse ResetOnSpawn activé (la valeur par défaut). - Insère un LocalScript dans
RoundHud, nomme-leRoundHudClientet colle le code ci-dessous. Il construit le label lui-même, donc il n'y a rien d'autre à dessiner. - Appuie sur Play. Le label en haut de l'écran affiche le statut et un compte à rebours au format
m:ss.
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.
| Situation | Ce qui se passe | Où 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 mourir | Comme une mort : il est éliminé. | player.CharacterRemoving appelle eliminate |
| Un joueur quitte le serveur | Il est retiré, ses connexions sont coupées, et le tick suivant recompte les camps. | Players.PlayerRemoving appelle eliminate |
| Un joueur arrive en pleine manche | Il 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 manche | Il n'est pas téléporté et attend dans le lobby. | getLivingCharacter |
| Tout le monde part ou meurt | La 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.
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.
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.
- 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
- Roblox Creator Docs : Add rounds (en anglais). la boucle de manches par équipes de Roblox dans l'exemple de laser tag
- Roblox Creator Docs : PVInstance:PivotTo (en anglais). déplacer des modèles et des personnages depuis un script
- Roblox Creator Docs : Player (en anglais). LoadCharacterAsync, CharacterRemoving et RequestStreamAroundAsync
- Roblox Creator Docs : Properties and attributes (en anglais). régler des attributs et détecter leurs changements
- Roblox Creator Docs : Implement teams (en anglais). ajouter des équipes et l'attribution automatique
- Roblox Creator Docs : Studio testing modes (en anglais). le test à plusieurs clients Server & Clients
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.