Catégorie : ROBLOX

Ce système affiche un chrono qui mesure le temps mis par un joueur pour aller d’un bloc de départ à un bloc d’arrivée.

Le script serveur est placé sur les blocs (départ/arrivée) : il détecte quand le joueur les touche (Touched) et décide quand le chrono doit démarrer ou s’arrêter.

Le LocalScript, lui, tourne uniquement sur l’ordinateur du joueur : il gère l’affichage du chrono à l’écran (le TextLabel).

Le serveur ne peut pas modifier directement l’écran d’un joueur : il doit envoyer un message au client via un RemoteEvent.

Le RemoteEvent fonctionne comme une messagerie entre le serveur et le client : quand le joueur touche le bloc de départ, le serveur « fire » (envoie) l’événement StartEvent.

Le LocalScript écoute cet événement avec OnClientEvent:Connect(...) et, dès qu’il le reçoit, enregistre l’heure de départ (tick()) et active running = true.

De la même façon, quand le joueur touche le bloc d’arrivée, le serveur envoie WinEvent, et le LocalScript reçoit ce signal pour arrêter le chrono (running = false).

Pendant que running est actif, la fonction RunService.Heartbeat recalcule et affiche le temps écoulé à chaque frame (60 fois par seconde environ).

La fonction formatTime transforme le nombre de secondes brut en un affichage lisible du type 01:23 (minutes:secondes).

En résumé : le serveur décide (quand démarrer/arrêter), les RemoteEvents transmettent l’info, et le LocalScript affiche le résultat à l’écran du joueur.

Petit rappel pour bien comprendre

• Script serveur : tourne sur l’ordinateur qui héberge la partie. Il contrôle les règles du jeu, mais ne peut pas modifier ce qui s’affiche à l’écran d’un joueur précis.
• LocalScript : tourne uniquement sur l’ordinateur du joueur. Il gère l’affichage (interface, sons, caméra…) mais ne peut pas être utilisé pour des règles importantes du jeu (sinon un joueur pourrait tricher).
• RemoteEvent : le « pont » entre les deux. Le serveur envoie une info avec FireClient(), et le LocalScript la reçoit avec OnClientEvent:Connect().

QCM pour bien comprendre

1. Où s’exécute un LocalScript ?
A. Sur le serveur du jeu
B. Sur l’ordinateur du joueur uniquement
C. Sur tous les ordinateurs en même temps
D. Nulle part, c’est juste un fichier texte

2. Pourquoi ne peut-on pas modifier directement le TextLabel depuis le script serveur ?
A. Parce que c’est interdit par Roblox
B. Parce que le serveur n’a pas accès à l’affichage local de chaque joueur
C. Parce que le TextLabel n’existe pas sur le serveur
D. Parce que ça coûte trop cher en mémoire

3. À quoi sert un RemoteEvent ?
A. À supprimer un joueur du jeu
B. À transmettre une information entre le serveur et un client
C. À changer la couleur d’un bloc automatiquement
D. À sauvegarder les données du joueur

4. Que fait startEvent:FireClient(player) côté serveur ?
A. Il supprime le joueur
B. Il envoie un signal au client précis pour déclencher une action
C. Il démarre le jeu pour tous les joueurs
D. Il crée un nouveau RemoteEvent

5. Que fait RunService.Heartbeat dans ce script ?
A. Il vérifie les battements de cœur du joueur
B. Il exécute du code à chaque frame, ici pour actualiser l’affichage du chrono
C. Il redémarre le serveur régulièrement
D. Il compte le nombre de joueurs connectés

6. Que se passe-t-il si running vaut false ?
A. Le chrono continue de s’incrémenter
B. Le texte du chrono arrête de se mettre à jour
C. Le joueur est téléporté au départ
D. Le RemoteEvent est détruit

Crée un part pour déterminer le départ du chrono et un part pour déterminer le stop du chrono.

Puis deux RemoteEvent pour gérer le démarrage et l’arrêt du chrono :

Puis script sur le serveur pour gérer les collisions entre le player et les parts de départ et d’arrivée :

local replicatedStorage = game:GetService("ReplicatedStorage")
local remoteEvent = replicatedStorage:WaitForChild("Coursetimecheck")

local startEvent = remoteEvent.StartEvent
local winEvent = remoteEvent.WinEvent

local start = script.Parent.StartPart
local succes = script.Parent.SuccessPart

succes.SurfaceGui.Enabled = false
succes.ParticleEmitter.Enabled = false

succes.Anchored = true
succes.CanCollide = true
succes.CanTouch = true

start.Anchored = true
start.CanCollide = false
start.CanTouch = true
start.Transparency = 1

succes.Touched:Connect(function(hit)
	local character = hit.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")
	if not humanoid then return end
	if succes.SurfaceGui.Enabled then return end
	
	remoteEvent.WinEvent:FireClient(game.Players:GetPlayerFromCharacter(character))

	succes.SurfaceGui.Enabled = true
	succes.ParticleEmitter.Enabled = true
end)

start.Touched:Connect(function(hit)
	local character = hit.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")
	if not humanoid then return end
	
	local player = game.Players:GetPlayerFromCharacter(character)
	if not player then return end -- sécurité si ce n'est pas un joueur (NPC par ex.)

	print("StartEvent déclenché pour " .. player.Name)

	startEvent:FireClient(player)
	
end)

Et également un localScript pour l’affichage du chrono pour le joueur :

-- Récupération des services
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

-- Récupération du joueur actuel et de la PlayerGui
local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

-- Récupération de l'UI du chrono
local chrono = playerGui:WaitForChild("ScreenGui"):WaitForChild("Frame"):WaitForChild("ChronoLabel")

-- Récupération des RemoteEvents start et stop du chrono
local remoteEventsFolder = ReplicatedStorage:WaitForChild("Coursetimecheck")
local startEvent = remoteEventsFolder:WaitForChild("StartEvent")
local stopEvent = remoteEventsFolder:WaitForChild("WinEvent")

-- Fonction pour formater le temps en minutes:secondes
local function formatTime(t)
	local minutes = math.floor(t / 60)
	local seconds = math.floor(t % 60)
	return string.format("%02d:%02d", minutes, seconds)
end

-- Variables globales pour suivre le temps et l'état du chrono
local startTime = nil
chrono.Text = "00:00"
local running = false

-- Connexion des événements serveur au client
startEvent.OnClientEvent:Connect(function()
	startTime = tick()
	running = true
end)

stopEvent.OnClientEvent:Connect(function()
	running = false
end)

-- Mise à jour continue de l'affichage du chrono
RunService.Heartbeat:Connect(function()
	if not running or not startTime then return end
	chrono.Text = formatTime(tick() - startTime)
end)

Ce script est attaché à un Part (bloc) et détecte quand un joueur le touche, via l’événement Touched.

Il vérifie que c’est bien un personnage avec un Humanoid, et bloque les déclenchements répétés grâce à un système de cooldown (table cooldowns).

Si le joueur n’a pas encore été rétréci/agrandi, le script sauvegarde sa taille actuelle dans un dossier Scale, puis applique la taille SCALEMAX (0.3) à sa hauteur, largeur, profondeur et tête.

Si le joueur a déjà été modifié (le dossier Scale existe), le script lui redonne sa taille d’origine et supprime le dossier.

Autrement dit : c’est un bloc « grandir/rétrécir » qui bascule (toggle) la taille du joueur à chaque contact, avec une seconde d’attente avant de pouvoir réutiliser le bloc.

QCM : Testez votre compréhension !

1. Que fait l’événement Touched dans ce script ?
A. Il vérifie si le joueur a cliqué sur le bloc
B. Il détecte quand quelque chose touche la Part
C. Il compte le nombre de joueurs dans le jeu
D. Il détruit le bloc

2. À quoi sert la variable COOLDOWN ?
A. À changer la couleur du bloc
B. À définir la taille maximale du joueur
C. À empêcher de réutiliser le bloc trop vite
D. À supprimer le personnage

3. Que se passe-t-il si le joueur touche le bloc une deuxième fois (après le cooldown) ?
A. Rien, ça ne marche qu’une fois
B. Le joueur reprend sa taille normale
C. Le joueur devient minuscule
D. Le jeu plante

4. À quoi sert le dossier (IntValue) nommé "Scale" ?
A. À afficher un message au joueur
B. À mémoriser la taille d’origine du joueur
C. À compter le temps de cooldown
D. À stocker le nom du joueur

5. Pourquoi utilise-t-on une table cooldowns avec le character comme clé ?
A. Pour donner un nom à chaque joueur
B. Pour savoir si CE joueur précis est en cooldown
C. Pour compter les points de chaque joueur
D. Pour changer la vitesse du joueur

local part = script.Parent

local SCALEMAX = 0.3

local COOLDOWN = 1 -- secondes avant de pouvoir re-déclencher
local cooldowns = {} -- [character] = true pendant le cooldown

part.Touched:Connect(function(plr)
	local character = plr.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")
	if not humanoid  then return end

	if cooldowns[character] then return end
	cooldowns[character] = true

	local existingFolder = humanoid:FindFirstChild("Scale")

	if existingFolder then
		humanoid.BodyHeightScale.Value = existingFolder.Value
		humanoid.BodyWidthScale.Value = existingFolder.Value		
		humanoid.BodyDepthScale.Value = existingFolder.Value	
		humanoid.HeadScale.Value = existingFolder.Value
		existingFolder:Destroy()
	else
		local folder = Instance.new("IntValue")
		folder.Name = "Scale"
		folder.Parent = humanoid
		folder.Value = humanoid.BodyHeightScale.Value
		humanoid.BodyHeightScale.Value = SCALEMAX
		humanoid.BodyWidthScale.Value = SCALEMAX		
		humanoid.BodyDepthScale.Value = SCALEMAX	
		humanoid.HeadScale.Value = SCALEMAX
	end

	task.wait(COOLDOWN)
	cooldowns[character] = nil

end)

Voici l’explication du code, ligne par ligne :

Les variables de départ

local teleports = script.Parent
local teleportA = teleports.TeleportA
local teleportB = teleports.TeleportB

On récupère deux objets dans le jeu Roblox : la plateforme A (celle sur laquelle on va marcher) et la plateforme B (celle où on va arriver). Ces deux plateformes sont des enfants du script dans l’arbre du jeu.

L’événement Touched

teleportA.Touched:Connect(function(hit)

Touched est un événement Roblox : il se déclenche automatiquement dès que quelque chose touche la plateforme A. Le paramètre hit contient la pièce (la partie du corps) qui l’a touchée.

La vérification du joueur

local character = hit.Parent
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 then return end

On remonte d’un niveau pour trouver le personnage entier (hit.Parent), puis on cherche s’il contient un Humanoid (ce qui prouve que c’est bien un joueur, pas un mur ou une balle). Si rien de valide n’est trouvé, ou si le joueur est mort (Health <= 0), on arrête tout avec return.

La téléportation

local offset = Vector3.new(0, 2, 0)
character:PivotTo(CFrame.new(teleportB.Position + offset))

Vector3.new(0, 2, 0) crée un décalage de 2 unités vers le haut pour que le joueur atterrisse au-dessus de la plateforme B et pas à l’intérieur. PivotTo est la fonction qui déplace instantanément tout le personnage à une nouvelle position — c’est ça la téléportation !

Le code complet de la téléportation

-- Configuration
local teleports = script.Parent
local teleportA = teleports.TeleportA
local teleportB = teleports.TeleportB

teleportA.Touched:Connect(function(hit)
	-- Récupération du joueur
	local character = hit.Parent
	local humanoid  = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then return end
	
	-- Décalage légert vers le haut pour poser le joueur sur la plateforme
	local offset = Vector3.new(0, 2, 0)
	character:PivotTo(CFrame.new(teleportB.Position + offset))

end)

Objectif : Créé un tableau de scores

Créer un script pour afficher un tableau de score au joueur sousServerScriptService :

Renommer le script leaderstats :

Saisir le code suivant pour un affichage d’une barre de scores :

local players = game:GetService("Players")

players.PlayerAdded:Connect(function(player)
     local leaderstats = Instance.new("Folder")
     leaderstats.Name = "leaderstats"
     leaderstats.Parent = player
end)

Si tu lances ton jeu une barre s’affiche :

Si le score ne s’affiche pas vérifie :

Rajoute à ton script un score à afficher :

local players = game:GetService("Players")

players.PlayerAdded:Connect(function(player)

     local leaderstats = Instance.new("Folder")
     leaderstats.Name = "leaderstats"
     leaderstats.Parent = player

     local score = Instance.new("IntValue")
     score.Parent = leaderstats
     score.Name = "Score"
     score.Value = 0

end)

Le score s’affiche si tu lances ton jeu :

Exemple d’un script pour augmenter le score si le joueur click sur un ClickDetector :

local clickDetector = script.Parent.ClickDetector

clickDetector.MouseClick:Connect(function(player)

      player:WaitForChild("leaderstats").Score.Value += 10

end)

Exemple d’un script pour augmenter le score si le joueur rentre en collision avec un part :

local myPart = script.Parent


myPart.Touched:Connect(function(hit)

	-- Vérifie si c'est un joueur qui a touché la part
	local joueur = game:GetService("Players"):GetPlayerFromCharacter(hit.Parent)
	if joueur then
		-- Trouve le score du joueur dans Leaderstats
		local leaderstats = joueur:FindFirstChild("leaderstats")
		if leaderstats then
			local score = leaderstats:FindFirstChild("Score")
			if score then
				-- Incrémente le score
				score.Value = score.Value + 1
			end
		end
	end

end)

Exemple d’un script pour augmenter le score si le joueur rentre en collision avec un part :

local myPart = script.Parent


myPart.Touched:Connect(function(hit)

	-- Vérifie si c'est un joueur qui a touché la part
	local joueur = game:GetService("Players"):GetPlayerFromCharacter(hit.Parent)
	if joueur then
		-- Trouve le score du joueur dans Leaderstats
		local leaderstats = joueur:FindFirstChild("leaderstats")
		if leaderstats then
			local score = leaderstats:FindFirstChild("Score")
			if score then
				-- Incrémente le score
				score.Value = score.Value + 1
			end
		end
	end

end)

Un système de score avec un ModuleScript

1. Créer un ModuleScript pour gérer les scores

-- ModuleScript dans ServerScriptService : "ScoreManager"
local ScoreManager = {}

-- Initialise le Leaderstats pour un joueur
function ScoreManager.initPlayer(player)
    local leaderstats = Instance.new("Folder", player)
    leaderstats.Name = "leaderstats"

    local points = Instance.new("IntValue", leaderstats)
    points.Name = "Score"
    points.Value = 0
end

-- Met à jour le score d'un joueur
function ScoreManager.addPoints(player, points)
    local leaderstats = player:FindFirstChild("leaderstats")
    if leaderstats then
        local score = leaderstats:FindFirstChild("Score")
        if score then
            score.Value = score.Value + points
        end
    end
end

return ScoreManager

Appel dans scriptServeur pour rajouter des points :

-- Script dans ServerScriptService
local ScoreManager = require(game:GetService("ServerScriptService"):WaitForChild("ScoreManager"))

-- Initialiser le Leaderstats pour chaque joueur
game.Players.PlayerAdded:Connect(function(player)
	ScoreManager.initPlayer(player)
end)

local part = workspace.Part -- La Part qui déclenche l'événement

-- Exemple : Ajouter 10 points à un joueur
part.Touched:Connect(function(otherPart)
	-- Vérifie que otherPart fait partie d'un personnage
	local humanoid = otherPart.Parent:FindFirstChild("Humanoid")
	if humanoid then
		-- Récupère le joueur associé au personnage
		local player = game.Players:GetPlayerFromCharacter(otherPart.Parent)
		if player then            
			ScoreManager.addPoints(player, 10)
			part:Destroy() -- Supprime la Part après utilisation

		end
	end
end)

As-tu déjà rêvé de faire bondir les joueurs à plusieurs mètres de hauteur dans ton jeu Roblox ? Elles peuvent servir à franchir un obstacle, atteindre une plateforme cachée ou simplement ajouter une touche amusante à un niveau. Dans ce tutoriel, tu vas découvrir comment transformer un simple part en véritable trampoline interactif. Tu verras également comment régler la puissance du rebond pour obtenir différents effets de jeu.

Rebond du joueur sur la plaque

Crée un part et dessous un script :

Saisie ce code dans le script :

local TweenService = game:GetService("TweenService")

local BOUNCE_SPEED = 120    -- vitesse verticale imposée (studs/s)
local COOLDOWN     = 0.3   -- évite les rebonds multiples par contact

local trampoline  = script.Parent
local lastBounce   = {}     -- cooldown par joueur

local function squish(trampoline, bounceSpeed, squishTime)
	
	if bounceSpeed==nil then bounceSpeed = BOUNCE_SPEED end
	
	-- Remplace directement la vélocité verticale
	local vel = trampoline.AssemblyLinearVelocity
	trampoline.AssemblyLinearVelocity = Vector3.new(vel.X, bounceSpeed, vel.Z)
	
end

-- Appliquer des propriétés physiques pour que la part soit glissante
trampoline.CustomPhysicalProperties = PhysicalProperties.new(
	0.7, -- Density
	1,   -- Friction
	1,   -- Elasticity
	1,   -- FrictionWeight
	1    -- ElasticityWeight
)
-- Appliquer un matériau glissant comme de la glace
trampoline.Material = Enum.Material.Carpet

trampoline.Touched:Connect(function(hit)
	local character = hit.Parent
	local humanoid  = character:FindFirstChildWhichIsA("Humanoid")
	if not humanoid or humanoid.Health <= 0 then return end

	local rootPart = character:FindFirstChild("HumanoidRootPart")
	if not rootPart then return end

	-- Cooldown par personnage
	local now = tick()
	if lastBounce[character] and (now - lastBounce[character]) < COOLDOWN then return end
	lastBounce[character] = now

	squish(trampoline)
end)

Ce script transforme une simple pièce Roblox en trampoline capable de faire rebondir les joueurs lorsqu’ils la touchent. Les variables BOUNCE_SPEED et COOLDOWN définissent respectivement la puissance du rebond et le temps d’attente avant qu’un même joueur puisse rebondir à nouveau. Les propriétés physiques et le matériau de la pièce sont modifiés pour lui donner l’apparence et le comportement d’une surface adaptée au rebond.

La fonction squish() applique une nouvelle vitesse verticale à la pièce afin de créer l’effet de propulsion vers le haut.

L’événement Touched détecte lorsqu’un objet entre en contact avec le trampoline et vérifie qu’il s’agit bien d’un personnage vivant possédant un Humanoid. Un système de cooldown mémorise l’instant du dernier rebond de chaque joueur afin d’éviter plusieurs déclenchements successifs lorsque le personnage reste en contact avec le trampoline.

Animation de la plaque comme un trampoline

Par rapport à la version précédente, le script suivant ajoute un effet visuel d’écrasement et de retour à la forme initiale, ce qui donne davantage l’impression qu’il s’agit d’un véritable trampoline.

Une nouvelle variable originalSize mémorise la taille initiale de la plaque afin de pouvoir la restaurer après l’animation. La constante SQUISH_TIME définit la durée de l’animation de compression et de retour à la normale. La table isSquishing empêche que plusieurs animations soient lancées en même temps sur la même plaque, ce qui éviterait des déformations incohérentes. Le service TweenService est utilisé pour créer une animation fluide plutôt qu’un changement instantané de taille.

Lorsqu’un joueur rebondit, la plaque s’aplatit : sa hauteur diminue tandis que sa largeur et sa longueur augmentent légèrement. Cela reproduit visuellement le comportement d’un trampoline qui se comprime sous le poids du joueur. Après un court délai, une seconde animation redonne progressivement à la plaque sa taille d’origine, donnant l’impression qu’elle reprend sa forme après avoir propulsé le joueur.

L’effet visuel est synchronisé avec le rebond du joueur, ce qui rend l’interaction plus réaliste et plus agréable à observer.

local TweenService = game:GetService("TweenService")

local BOUNCE_SPEED = 120    -- vitesse verticale imposée (studs/s)
local COOLDOWN     = 0.3   -- évite les rebonds multiples par contact
local SQUISH_TIME  = 0.08  -- durée de l'étirement en secondes

local trampoline  = script.Parent

local lastBounce   = {}     -- cooldown par joueur
local isSquishing  = {}		-- marquage de la part en état d'étirement

local function squish(trampoline, bounceSpeed, squishTime)
	
	if bounceSpeed==nil then bounceSpeed = BOUNCE_SPEED end
	if squishTime==nil then squishTime = SQUISH_TIME end

	local originalSize = trampoline.Size

	-- Remplace directement la vélocité verticale
	local vel = trampoline.AssemblyLinearVelocity
	trampoline.AssemblyLinearVelocity = Vector3.new(vel.X, bounceSpeed, vel.Z)
	
	if isSquishing[trampoline] then return end
	isSquishing[trampoline] = true
	local tweenInfo = TweenInfo.new(squishTime, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
	TweenService:Create(trampoline, tweenInfo, {
		Size = Vector3.new(originalSize.X * 1.05, originalSize.Y * 0.4, originalSize.Z * 1.05)
	}):Play()
	task.delay(SQUISH_TIME, function()
		TweenService:Create(trampoline, tweenInfo, { Size = originalSize }):Play()
		task.delay(SQUISH_TIME, function() isSquishing[trampoline] = false end)
	end)
end

-- Appliquer des propriétés physiques pour que la part soit glissante
trampoline.CustomPhysicalProperties = PhysicalProperties.new(
	0.7, -- Density
	1,   -- Friction
	1,   -- Elasticity
	1,   -- FrictionWeight
	1    -- ElasticityWeight
)
-- Appliquer un matériau glissant comme de la glace
trampoline.Material = Enum.Material.Carpet

trampoline.Touched:Connect(function(hit)
	local character = hit.Parent
	local humanoid  = character:FindFirstChildWhichIsA("Humanoid")
	if not humanoid or humanoid.Health <= 0 then return end

	local rootPart = character:FindFirstChild("HumanoidRootPart")
	if not rootPart then return end

	-- Cooldown par personnage
	local now = tick()
	if lastBounce[character] and (now - lastBounce[character]) < COOLDOWN then return end
	lastBounce[character] = now

	squish(trampoline)
end)

Système de plaques rebondissantes

Modifie la structure en créant un Folder, sous le folder ton script et la part, puis duplique la plaque rebondissante plusieurs fois :

Modifie ton script pour lire tous les parts rebondissants :

local TweenService = game:GetService("TweenService")

local BOUNCE_SPEED = 120    -- vitesse verticale imposée (studs/s)
local COOLDOWN     = 0.3   -- évite les rebonds multiples par contact
local SQUISH_TIME  = 0.08  -- durée de l'étirement en secondes

local trampolines  = script.Parent
local lastBounce   = {}     -- cooldown par joueur
local isSquishing  = {}		-- marquage de la part en état d'étirement

local function squish(trampoline, bounceSpeed, squishTime)

	if bounceSpeed==nil then bounceSpeed = BOUNCE_SPEED end
	if squishTime==nil then squishTime = SQUISH_TIME end
	
	local originalSize = trampoline.Size
	
	-- Remplace directement la vélocité verticale
	local vel = trampoline.AssemblyLinearVelocity
	trampoline.AssemblyLinearVelocity = Vector3.new(vel.X, bounceSpeed, vel.Z)

	if isSquishing[trampoline] then return end
	isSquishing[trampoline] = true
	local tweenInfo = TweenInfo.new(squishTime, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
	TweenService:Create(trampoline, tweenInfo, {
		Size = Vector3.new(originalSize.X * 1.05, originalSize.Y * 0.4, originalSize.Z * 1.05)
	}):Play()
	task.delay(SQUISH_TIME, function()
		TweenService:Create(trampoline, tweenInfo, { Size = originalSize }):Play()
		task.delay(SQUISH_TIME, function() isSquishing[trampoline] = false end)
	end)
end

for _, trampoline in ipairs(trampolines:GetChildren()) do
	if not trampoline:IsA("BasePart") then continue end

	-- Appliquer des propriétés physiques pour que la part soit glissante
	trampoline.CustomPhysicalProperties = PhysicalProperties.new(
		0.7, -- Density
		1,   -- Friction
		1,   -- Elasticity
		1,   -- FrictionWeight
		1    -- ElasticityWeight
	)
	-- Appliquer un matériau glissant comme de la glace
	trampoline.Material = Enum.Material.Carpet



	trampoline.Touched:Connect(function(hit)
		local character = hit.Parent
		local humanoid  = character:FindFirstChildWhichIsA("Humanoid")
		if not humanoid or humanoid.Health <= 0 then return end

		local rootPart = character:FindFirstChild("HumanoidRootPart")
		if not rootPart then return end

		-- Cooldown par personnage
		local now = tick()
		if lastBounce[character] and (now - lastBounce[character]) < COOLDOWN then return end
		lastBounce[character] = now

		squish(trampoline)
	end)
	
end

Dans beaucoup de jeux Roblox, il existe des zones spéciales qui changent complètement la manière de jouer. Imagine un sol où ton personnage se met à glisser tout seul, comme sur de la glace, sans pouvoir s’arrêter immédiatement. Ou encore une pente qui accélère ton déplacement, te propulsant vers une nouvelle plateforme. Ces effets simples transforment un niveau classique en un vrai parcours d’obstacles amusant et dynamique. Dans ce tutoriel, tu vas apprendre à créer ce type de mécanismes toi-même avec Lua dans Roblox Studio. Tu vas découvrir comment contrôler le comportement d’un joueur lorsqu’il touche une zone spéciale. Tu vas progresser étape par étape pour comprendre comment la physique du jeu peut être modifiée. À la fin, tu seras capable de concevoir tes propres zones de glisse comme dans les vrais jeux d’obby.

Ce tutoriel est organisé en trois parties :

• La première te montrera comment créer une plaque glissante simple pour faire “patiner” un joueur.
• La deuxième expliquera comment gérer une plaque en pente pour influencer la direction du déplacement.
• Enfin, la troisième partie te permettra de combiner plusieurs plaques glissantes pour créer un parcours complet et dynamique.

Plaque glissante

Crée un part puis dessous un script :

Ce script transforme une Part en surface glissante grâce à des propriétés physiques qui réduisent les frottements et lui donnent l’apparence de la glace. Lorsqu’un joueur touche cette Part, le script vérifie qu’il s’agit bien d’un personnage et récupère son HumanoidRootPart, qui représente le centre de son déplacement. Il calcule ensuite la direction dans laquelle regarde le joueur à l’aide du LookVector. La Part reçoit alors une vitesse SPEED qui la fait glisser dans la direction choisie pendant une durée définie SLIDER_LENGTH. Enfin, après ce délai, la vitesse est remise à zéro pour arrêter la glissade.

-- Script pour une part qui glisse sur un joueur lorsqu'il la touche
local part = script.Parent

-- Appliquer des propriétés physiques pour que la part soit glissante
part.CustomPhysicalProperties = PhysicalProperties.new(
	0.7, -- Density
	0,   -- Friction
	0,   -- Elasticity
	0,   -- FrictionWeight
	1    -- ElasticityWeight
)
-- Appliquer un matériau glissant comme de la glace
part.Material = Enum.Material.Ice

-- Vitesse de déplacement de la glissade
local SPEED = 15
local SLIDER_LENGTH = 1

-- Fonction appelée lorsque la part est touchée
part.Touched:Connect(function(hit)
	-- Vérifier si l'objet touché est un personnage
	local character = hit:FindFirstAncestorOfClass("Model")
	if not character then return end
	-- Récupérer le joueur et sa racine
	local rootPart = character:FindFirstChild("HumanoidRootPart")
	if not rootPart then return end
    -- Récupérer la direction de la caméra du joueur
	local dir = rootPart.CFrame.LookVector
	-- Appliquer une impulsion sur la part pour faire glisser le joueur dans la direction de la caméra
	part.AssemblyLinearVelocity = dir * SPEED
	-- Arrêter la glissade après un délai
	task.spawn(function()
		task.wait(SLIDER_LENGTH)
		part.AssemblyLinearVelocity = Vector3.zero		
		end)

end)

Pente glissante

Modifie le code pour permettre à la plaque glissante de tenir compte de son inclinaison.

Une nouvelle fonction, getSurfaceInclination, calcule la direction naturelle de la pente à partir de la gravité et de la normale de la surface. La gravité indique toujours le bas, tandis que la normale renseigne sur l’orientation de la plaque. En combinant ces deux informations, le script détermine la direction dans laquelle un objet glisserait naturellement sur la pente.

Lorsque le joueur touche la plaque, le script calcule cette direction de glissade et vérifie si elle est suffisamment importante. Si la plaque est inclinée, la vitesse est appliquée dans le sens de la pente afin de simuler une descente naturelle. Si la plaque est horizontale, il n’y a pas de direction de pente significative : le joueur glisse alors dans la direction vers laquelle il regarde. Grâce à cet ajout, le même script peut gérer aussi bien une plaque plate qu’une plaque inclinée, ce qui rend le comportement plus réaliste et permet de créer des parcours plus variés.

-- Script pour une part qui glisse sur un joueur lorsqu'il la touche
local part = script.Parent

-- Appliquer des propriétés physiques pour que la part soit glissante
part.CustomPhysicalProperties = PhysicalProperties.new(
	0.7, -- Density
	0,   -- Friction
	0,   -- Elasticity
	0,   -- FrictionWeight
	1    -- ElasticityWeight
)
-- Appliquer un matériau glissant comme de la glace
part.Material = Enum.Material.Ice

-- Vitesse de déplacement de la glissade
local SPEED = 15
local SLIDER_LENGTH = 1

local function getSurfaceInclination(hit)
	-- Récupérer la direction de la gravité
	local gravity = Vector3.new(0, -1, 0)
	-- Récupérer la normale de la surface de la part
	-- la normale est un vecteur unitaire perpendiculaire à la surface
	-- qui indique “dans quel sens la surface est orientée"
	local normal = part.CFrame.UpVector
	-- enlève la composante perpendiculaire à la surface
	local slopeDirection = gravity - normal * gravity:Dot(normal)
	return slopeDirection.Unit
end

-- Fonction appelée lorsque la part est touchée
part.Touched:Connect(function(hit)
	-- Vérifier si l'objet touché est un personnage
	local character = hit:FindFirstAncestorOfClass("Model")
	if not character then return end
	-- Récupérer le joueur et sa racine
	local rootPart = character:FindFirstChild("HumanoidRootPart")
	if not rootPart then return end
    -- Récupérer la direction de la caméra du joueur
	local dir = rootPart.CFrame.LookVector
	-- Récuoération du sens de la pente de la part par rapport à la gravité
	local slopeDirection = getSurfaceInclination(part)

	-- Glissade en fonction si pente de la part ou part horizontale
	if slopeDirection.Magnitude > 0.1 then
		-- Appliquer une impulsion sur la part pour faire glisser le joueur dans la direction de la pente
		part.AssemblyLinearVelocity = slopeDirection * SPEED
	else
		-- Appliquer une impulsion sur la part pour faire glisser le joueur dans la direction de la caméra
		part.AssemblyLinearVelocity = dir * SPEED
		-- Arrêter la glissade après un délai
		task.spawn(function()
			task.wait(SLIDER_LENGTH)
			part.AssemblyLinearVelocity = Vector3.zero		
		end)
	end

end)

Systèmes de plaques et pentes glissantes

Dans cette nouvelle version, le script ne gère plus une seule plaque glissante mais un ensemble de plaques regroupées dans un dossier (Folder). Au démarrage, le script récupère tous les objets contenus dans ce dossier puis les parcourt un par un grâce à une boucle.

local folder = script.Parent
local parts = folder:GetChildren()

for _, part in pairs(parts) do

end

Une vérification est effectuée pour s’assurer que chaque objet est bien une BasePart afin d’éviter les erreurs avec d’autres types d’objets.

if not part:IsA("BasePart") then continue end

Pour chaque plaque trouvée, les propriétés physiques et le matériau de glace sont appliqués automatiquement. Cela évite de dupliquer le même script sur chaque plaque du parcours. La fonction de calcul de la pente est ensuite associée à chaque plaque afin que son inclinaison soit prise en compte individuellement. Enfin, un événement Touched est créé pour chacune d’elles : lorsqu’un joueur touche une plaque, le script utilise les caractéristiques propres à cette plaque (orientation, pente, vitesse de glisse) pour déterminer son déplacement.

Grâce à cette modification, il devient très simple de créer un parcours complet composé de nombreuses surfaces glissantes. Il suffit d’ajouter ou de supprimer des plaques dans le dossier pour que le script les prenne automatiquement en charge, sans aucune modification supplémentaire du code.

-- Script pour une part qui glisse sur un joueur lorsqu'il la touche
local folder = script.Parent
local parts = folder:GetChildren()

for _, part in pairs(parts) do
	
	if not part:IsA("BasePart") then continue end
	
	-- Appliquer des propriétés physiques pour que la part soit glissante
	part.CustomPhysicalProperties = PhysicalProperties.new(
		0.7, -- Density
		0,   -- Friction
		0,   -- Elasticity
		0,   -- FrictionWeight
		1    -- ElasticityWeight
	)
	-- Appliquer un matériau glissant comme de la glace
	part.Material = Enum.Material.Ice

	-- Vitesse de déplacement de la glissade
	local SPEED = 15
	local SLIDER_LENGTH = 3

	local function getSurfaceInclination(hit)
		-- Récupérer la direction de la gravité
		local gravity = Vector3.new(0, -1, 0)
		-- Récupérer la normale de la surface de la part
		-- la normale est un vecteur unitaire perpendiculaire à la surface
		-- qui indique “dans quel sens la surface est orientée"
		local normal = part.CFrame.UpVector
		-- enlève la composante perpendiculaire à la surface
		local slopeDirection = gravity - normal * gravity:Dot(normal)
		return slopeDirection.Unit
	end
	
	-- Fonction appelée lorsque la part est touchée
	part.Touched:Connect(function(hit)
		-- Vérifier si l'objet touché est un personnage
		local character = hit:FindFirstAncestorOfClass("Model")
		if not character then return end
		-- Récupérer le joueur et sa racine
		local rootPart = character:FindFirstChild("HumanoidRootPart")
		if not rootPart then return end
		-- Récupérer la direction de la caméra du joueur
		local dir = rootPart.CFrame.LookVector
		-- Récuoération du sens de la pente de la part par rapport à la gravité
		local slopeDirection = getSurfaceInclination(part)

		-- Glissade en fonction si pente de la part ou part horizontale
		if slopeDirection.Magnitude > 0.1 then
			-- Appliquer une impulsion sur la part pour faire glisser le joueur dans la direction de la pente
			part.AssemblyLinearVelocity = slopeDirection * SPEED
		else
			-- Appliquer une impulsion sur la part pour faire glisser le joueur dans la direction de la caméra
			part.AssemblyLinearVelocity = dir * SPEED
			-- Arrêter la glissade après un délai
			task.spawn(function()
				task.wait(SLIDER_LENGTH)
				part.AssemblyLinearVelocity = Vector3.zero		
			end)
		end

	end)

end

Dans ce tutoriel, tu vas créer une plaque spéciale qui modifie la gravité lorsque le joueur marche dessus.

Grâce à cette plaque, les personnages pourront :

• sauter beaucoup plus haut ;
• retomber plus lentement ;
• atteindre des plateformes normalement inaccessibles.

Ce type de mécanisme est souvent utilisé dans les jeux de science-fiction, les parcours d’obstacles (Obby) ou les bases spatiales.

Comprendre la gravité

La gravité est la force qui attire les objets vers le sol.

Sur Terre, lorsque tu sautes :

1. tu montes ;
2. tu ralentis ;
3. tu redescends.

Dans Roblox, la gravité agit exactement de la même manière.

Si on la diminue :

• les sauts deviennent plus grands ;
• les chutes sont plus lentes ;
• les déplacements semblent plus légers.

Solution 1 : Modifier la gravité pour tout le monde

Dans cette version, lorsqu’un joueur active la plaque, la gravité du jeu entier est modifiée.

Conséquences

• tous les joueurs sont affectés ;
• tous les sauts deviennent plus grands ;
• tous les objets physiques réagissent également à la nouvelle gravité.

Cette solution est simple à mettre en place mais peut rendre le jeu imprévisible si plusieurs joueurs jouent en même temps.

Exemple de situation

Imaginons :

• Paul marche sur la plaque ;
• la gravité est divisée par deux.

Même les autres joueurs situés à l’autre bout de la carte profiteront immédiatement de cet effet.

Créer une plaque de non gravité

Commence par construire une Part qui servira de plaque spéciale.

Tu peux lui donner :

• une couleur vive ;
• un matériau futuriste ;
• un effet lumineux.

Les joueurs comprendront ainsi qu’il s’agit d’une zone particulière du parcours.

Détecter l’entrée du joueur

Lorsque le personnage marche sur la plaque, le jeu doit détecter le contact.

Cette détection permet de savoir :

• quel joueur est entré dans la zone ;
• quand appliquer l’effet de faible gravité.

C’est le même principe que pour une zone de téléportation ou un checkpoint.

Puis un script :

-- référence au part pour le changement de gravité
local part = script.Parent

-- détection du joueur qui touche la part
part.Touched:Connect(function(hit)
	local character = hit.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")	
	if not humanoid then return end
	-- changement de gravité à 10 au moment de la collision
	workspace.Gravity = 10
end)

Créer une plaque pour retrouver la gravité

Commence par construire une Part qui servira de plaque spéciale .

Puis un script :

-- référence de la part pour retourner la gravité à 196.2
local part = script.Parent

-- détection du joueur qui touche la part
part.Touched:Connect(function(hit)
	local character = hit.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")	
	if not humanoid then return end
	-- retour de la gravité à 196.2 au moment de la collision
	workspace.Gravity = 196.2
end)

Solution 2 : Modifier la gravité pour un seul joueur

Dans cette version, seul le joueur qui touche la plaque bénéficie de l’effet.

Les autres joueurs continuent à jouer normalement.

Cette méthode est souvent préférable dans un jeu multijoueur car chacun peut vivre sa propre expérience.

Comment simuler une faible gravité pour un joueur ?

Comme la gravité du monde est partagée par tous, on ne peut pas simplement changer la gravité globale pour un seul joueur.

On utilise donc une autre technique :

• augmenter sa puissance de saut ;
• ralentir sa descente ;
• modifier certaines propriétés de déplacement.

Le résultat ressemble à une gravité plus faible sans affecter les autres joueurs.

Script à modifier pour la plaque de changement de gravité pour un seul joueur :

-- référence au part pour le changement de gravité
local part = script.Parent

-- détection du joueur qui touche la part
part.Touched:Connect(function(hit)
	local character = hit.Parent
	local hrp = character and character:WaitForChild("HumanoidRootPart")
	
	if not hrp then return end
	
	if hrp:FindFirstChild("GravityAttachment") then return end -- évite les doublons
	
	-- 1. Créer une pièce jointe (Attachment) requise pour VectorForce
	local attachment = Instance.new("Attachment")
	attachment.Name = "GravityAttachment"
	attachment.Parent = hrp

	-- 2. Créer la force physique (VectorForce)
	local vectorForce = Instance.new("VectorForce")
	vectorForce.Name = "CustomGravityForce"
	vectorForce.Attachment0 = attachment
	vectorForce.ApplyAtCenterOfMass = true
	vectorForce.RelativeTo = Enum.ActuatorRelativeTo.World

	-- 3. Calculer la masse totale du personnage
	local totalMass = 0
	for _, part in ipairs(character:GetDescendants()) do
		if part:IsA("BasePart") then
			totalMass = totalMass + part:GetMass()
		end
	end

	-- 4. Appliquer une force vers le haut pour réduire la gravité ressentie
	-- Exemple : contrer 60% de la gravité (le joueur se sentira plus léger)
	local gravityCounterFactor = 0.6 
	local upwardForce = totalMass * workspace.Gravity * gravityCounterFactor

	vectorForce.Force = Vector3.new(0, upwardForce, 0)
	vectorForce.Parent = hrp
end)

Script à modifier pour retrouver la gravité normal pour un seul joueur :

-- référence de la part pour retourner la gravité à 196.2
local part = script.Parent

-- détection du joueur qui touche la part
part.Touched:Connect(function(hit)
	local character = hit.Parent
	local hrp = character and character:FindFirstChild("HumanoidRootPart")
	if not hrp then return end
	
	-- Trouver et supprimer l'Attachment
	local attachment = hrp:FindFirstChild("GravityAttachment")
	if attachment then
		attachment:Destroy()
	end

	-- Trouver et supprimer le VectorForce
	local vectorForce = hrp:FindFirstChild("CustomGravityForce")
	if vectorForce then
		vectorForce:Destroy()
	end
	
end)