Catégorie : Jeu vidéo

Part de pouvoir aléatoire

Auteur de l’article Par Patrick Gelinaud
Date de l’article 21 septembre 2026

Comprendre comment utiliser TweenService pour animer une partie (Part) dans Roblox, en changeant sa transparence, sa couleur, et ses propriétés physiques (comme CanCollide et CanTouch).

-- Récupérer le dossier et la partie "PowerPart" dans le Workspace
local powersFolder = workspace:WaitForChild("PowersFolder")
local powerPart = powersFolder:WaitForChild("PowerPart")

-- Variable pour contrôler l'exécution de la boucle (non utilisée ici, mais utile pour arrêter le script si besoin)
local isPowerActive = true

local POWER_DURATION = 5               -- Durée de l'animation "power" (en secondes)
local MAX_WITHOUT_POWER_DURATION = 10  -- Durée maximale entre deux activations (en secondes)
local MIN_WITHOUT_POWER_DURATION = 3   -- Durée minimale entre deux activations (en secondes)


-- Boucle infinie pour activer l'animation aléatoirement
task.spawn(function()
	while isPowerActive do
		
		-- Attendre un temps aléatoire entre MIN_WITHOUT_POWER_DURATION et MAX_WITHOUT_POWER_DURATION
		task.wait(math.random(MIN_WITHOUT_POWER_DURATION, MAX_WITHOUT_POWER_DURATION))

		-- Inverser les propriétés CanCollide et CanTouch
		powerPart.CanCollide = not powerPart.CanCollide
		powerPart.CanTouch = not powerPart.CanCollide

		-- Attendre que l'animation soit terminée
		task.wait(POWER_DURATION)

		-- Réactiver les collisions et le toucher
		powerPart.CanCollide = not powerPart.CanCollide
		powerPart.CanTouch = not powerPart.CanCollide
	end
end)

-- Détecter quand un joueur touche la partie
powerPart.Touched:Connect(function(hit)
	print("La partie PowerPart a été touchée !")
end)

Boucle infinie pour activer l’animation aléatoirement

task.spawn(function() ... end) : Crée une nouvelle tâche (thread) pour exécuter la boucle sans bloquer le reste du script.
while isPowerActive do ... end : Boucle infinie (tant que isPowerActive est true).
task.wait(math.random(MIN_WITHOUT_POWER_DURATION, MAX_WITHOUT_POWER_DURATION)) :
- Attend un temps aléatoire entre MIN_WITHOUT_POWER_DURATION (3 secondes) et MAX_WITHOUT_POWER_DURATION (10 secondes).
powerPart.CanCollide = not powerPart.CanCollide :
- Inverse la valeur de CanCollide (si c’était true, ça devient false, et vice versa).
task.wait(POWER_DURATION) : Temps d’action du pouvoir
Réactivation des propriétés :
- Après la fin de l’animation, on réactive CanCollide et CanTouch.

Ajouter dans cette partie de code le pouvoir à donner au joueur :

-- Détecter quand un joueur touche la partie
powerPart.Touched:Connect(function(hit)
	print("La partie PowerPart a été touchée !")
end)

Création de l’animation avec `TweenService`

La part change de couleur lorsque le pouvoir est possible :

-- Récupérer le dossier et la partie "PowerPart" dans le Workspace
local powersFolder = workspace:WaitForChild("PowersFolder")
local powerPart = powersFolder:WaitForChild("PowerPart")

-- Variable pour contrôler l'exécution de la boucle (non utilisée ici, mais utile pour arrêter le script si besoin)
local isPowerActive = true

-- Service pour créer des animations fluides
local TweenService = game:GetService("TweenService")

-- Durées et couleurs pour les animations
local POWER_DURATION = 5               -- Durée de l'animation "power" (en secondes)
local MAX_WITHOUT_POWER_DURATION = 10  -- Durée maximale entre deux activations (en secondes)
local MIN_WITHOUT_POWER_DURATION = 3   -- Durée minimale entre deux activations (en secondes)
local POWER_COLOR = Color3.fromRGB(0, 255, 0)          -- Couleur verte pour l'état "power"
local NO_POWER_COLOR = Color3.fromRGB(255, 0, 0)      -- Couleur rouge pour l'état "sans power"

-- Configurer la partie "PowerPart"
powerPart.Anchored = true            -- Empêcher la partie de bouger
powerPart.Transparency = 0           -- Rendre la partie complètement opaque
powerPart.CanCollide = true          -- Permettre les collisions avec la partie
powerPart.CanTouch = true            -- Permettre de détecter les touches sur la partie
powerPart.Color = NO_POWER_COLOR    -- Couleur initiale (rouge)

-- Créer une animation (Tween) pour la partie
-- Cette animation change la transparence, la couleur et désactive les collisions
local powerTween = TweenService:Create(
	powerPart,                          -- Objet à animer
	TweenInfo.new(
		POWER_DURATION,                 -- Durée de l'animation
		Enum.EasingStyle.Linear,        -- Style d'animation (linéaire)
		Enum.EasingDirection.InOut,     -- Direction de l'animation (aller-retour)
		0,                              -- Nombre de répétitions (0 = une seule fois)
		true                           -- Joue l'animation en boucle (inversée)
	),
	{
		Transparency = 0.8,            -- La partie devient semi-transparente
		CanCollide = false,             -- Désactive les collisions
		Color = POWER_COLOR             -- Change la couleur en vert
	}
)

-- Boucle infinie pour activer l'animation aléatoirement
task.spawn(function()
	while isPowerActive do
		-- Attendre un temps aléatoire entre MIN_WITHOUT_POWER_DURATION et MAX_WITHOUT_POWER_DURATION
		task.wait(math.random(MIN_WITHOUT_POWER_DURATION, MAX_WITHOUT_POWER_DURATION))

		-- Jouer l'animation
		powerTween:Play()

		-- Inverser les propriétés CanCollide et CanTouch
		powerPart.CanCollide = not powerPart.CanCollide
		powerPart.CanTouch = not powerPart.CanCollide

		-- Attendre que l'animation soit terminée
		powerTween.Completed:Wait()

		-- Réactiver les collisions et le toucher
		powerPart.CanCollide = not powerPart.CanCollide
		powerPart.CanTouch = not powerPart.CanCollide
	end
end)

-- Détecter quand un joueur touche la partie
powerPart.Touched:Connect(function(hit)
	print("La partie PowerPart a été touchée !")
end)

Configuration de la `PowerPart`

La PowerPart est configurée avec les propriétés suivantes :

Anchored = true : Empêche la partie de bouger (elle reste fixe dans le monde).
Transparency = 0 : La partie est complètement opaque (visible à 100%).
CanCollide = true : Les joueurs et objets peuvent entrer en collision avec la partie.
CanTouch = true : La partie peut détecter les touches (pour l’événement Touched).
Color = NO_POWER_COLOR : La couleur initiale est rouge (état « sans power »).

Création de l’animation avec `TweenService`

TweenService permet de créer des animations fluides pour modifier les propriétés d’un objet sur une durée donnée.

Paramètres de `TweenService:Create` :

Objet à animer : powerPart (la partie à animer).
TweenInfo.new : Définit les propriétés de l’animation :
- Durée : POWER_DURATION (5 secondes).
- Style : Enum.EasingStyle.Linear (animation linéaire, vitesse constante).
- Direction : Enum.EasingDirection.InOut (l’animation va et vient).
- Répétitions : 0 (une seule fois, mais true pour l’inverser à la fin).
- Boucle inversée : true (l’animation se joue en boucle aller-retour).
Propriétés à animer :
- Transparency = 0.8 : La partie devient semi-transparente.
- CanCollide = false : Désactive les collisions pendant l’animation.
- Color = POWER_COLOR : Change la couleur en vert.

QCM : Teste ta compréhension !

Sur les variables et la configuration :

À quoi sert powerPart.Anchored = true ?
- a) À empêcher la partie de bouger.
- b) À rendre la partie invisible.
- c) À changer la couleur de la partie.

Que fait powerPart.Transparency = 0 ?
- a) Rend la partie complètement opaque.
- b) Rend la partie complètement transparente.
- c) Rend la partie rouge.

Sur `TweenService` :

À quoi sert TweenService ?
- a) À créer des animations fluides pour les objets.
- b) À jouer des sons.
- c) À détecter les collisions.

Que fait TweenInfo.new(5, Enum.EasingStyle.Linear, Enum.EasingDirection.InOut, 0, true) ?
- a) Crée une animation de 5 secondes, linéaire, aller-retour, qui se joue une fois en boucle inversée.
- b) Crée une animation instantanée.
- c) Supprime l’objet après 5 secondes.

Quelles propriétés sont animées dans ce script ?
- a) Transparency, CanCollide, et Color.
- b) Size et Position.
- c) Name et Material.

Sur la boucle et les événements :

Pourquoi utilise-t-on task.spawn(function() ... end) ?
- a) Pour exécuter la boucle sans bloquer le reste du script.
- b) Pour arrêter le script.
- c) Pour créer un nouveau joueur.

Que fait math.random(MIN_WITHOUT_POWER_DURATION, MAX_WITHOUT_POWER_DURATION) ?
- a) Génère un nombre aléatoire entre MIN_WITHOUT_POWER_DURATION et MAX_WITHOUT_POWER_DURATION.
- b) Attend exactement 5 secondes.
- c) Désactive la partie.
  Réponse : a)

Que fait powerPart.Touched:Connect(function(hit) ... end) ?
- a) Exécute une fonction quand un objet touche la PowerPart.
- b) Change la taille de la PowerPart.
- c) Supprime la PowerPart.

Pourquoi inverse-t-on CanCollide et CanTouch dans la boucle ?
- a) Pour alterner entre un état où la partie est solide/touchable et un état où elle ne l’est pas.
- b) Pour changer la couleur de la partie.
- c) Pour supprimer la partie.

Changer la taille de la partie pendant l’animation

Objectif : Faire grandir ou rétrécir la PowerPart pendant l’animation.
Comment faire ?
- Ajoute Size = Vector3.new(10, 10, 10) dans les propriétés du Tween :luaCopier

-- Récupérer le dossier et la partie "PowerPart" dans le Workspace
local powersFolder = workspace:WaitForChild("PowersFolder")
local powerPart = powersFolder:WaitForChild("PowerPart")

-- Variable pour contrôler l'exécution de la boucle (non utilisée ici, mais utile pour arrêter le script si besoin)
local isPowerActive = true

-- Service pour créer des animations fluides
local TweenService = game:GetService("TweenService")

-- Durées et couleurs pour les animations
local POWER_DURATION = 5               -- Durée de l'animation "power" (en secondes)
local MAX_WITHOUT_POWER_DURATION = 10  -- Durée maximale entre deux activations (en secondes)
local MIN_WITHOUT_POWER_DURATION = 3   -- Durée minimale entre deux activations (en secondes)
local POWER_COLOR = Color3.fromRGB(0, 255, 0)          -- Couleur verte pour l'état "power"
local NO_POWER_COLOR = Color3.fromRGB(255, 0, 0)      -- Couleur rouge pour l'état "sans power"

-- Configurer la partie "PowerPart"
powerPart.Anchored = true            -- Empêcher la partie de bouger
powerPart.Transparency = 0           -- Rendre la partie complètement opaque
powerPart.CanCollide = true          -- Permettre les collisions avec la partie
powerPart.CanTouch = true            -- Permettre de détecter les touches sur la partie
powerPart.Color = NO_POWER_COLOR    -- Couleur initiale (rouge)

-- Créer une animation (Tween) pour la partie
-- Cette animation change la transparence, la couleur et désactive les collisions
local powerTween = TweenService:Create(
	powerPart,                          -- Objet à animer
	TweenInfo.new(
		POWER_DURATION,                 -- Durée de l'animation
		Enum.EasingStyle.Linear,        -- Style d'animation (linéaire)
		Enum.EasingDirection.InOut,     -- Direction de l'animation (aller-retour)
		0,                              -- Nombre de répétitions (0 = une seule fois)
		true                           -- Joue l'animation en boucle (inversée)
	),
	{
		Transparency = 0.8,            -- La partie devient semi-transparente
		CanCollide = false,             -- Désactive les collisions
		Color = POWER_COLOR,
		Size = Vector3.new(powerPart.Size.X + 10, powerPart.Size.Y + 10, powerPart.Size.Z)
	}
)

-- Boucle infinie pour activer l'animation aléatoirement
task.spawn(function()
	while isPowerActive do
		-- Attendre un temps aléatoire entre MIN_WITHOUT_POWER_DURATION et MAX_WITHOUT_POWER_DURATION
		task.wait(math.random(MIN_WITHOUT_POWER_DURATION, MAX_WITHOUT_POWER_DURATION))

		-- Jouer l'animation
		powerTween:Play()

		-- Inverser les propriétés CanCollide et CanTouch
		powerPart.CanCollide = not powerPart.CanCollide
		powerPart.CanTouch = not powerPart.CanCollide

		-- Attendre que l'animation soit terminée
		powerTween.Completed:Wait()

		-- Réactiver les collisions et le toucher
		powerPart.CanCollide = not powerPart.CanCollide
		powerPart.CanTouch = not powerPart.CanCollide
	end
end)

-- Détecter quand un joueur touche la partie
powerPart.Touched:Connect(function(hit)
	print("La partie PowerPart a été touchée !")
end)

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Supprimer la Baseplate au lancement du jeu

Auteur de l’article Par Patrick Gelinaud
Date de l’article 16 septembre 2026

Qu’est-ce que la Baseplate ?

Dans Roblox Studio, la Baseplate est une pièce fondamentale de ton monde. C’est une grande plaque plane (généralement verte) qui sert de sol de base pour ton jeu. Elle permet aux joueurs et aux objets de :

Se tenir debout (sans elle, les personnages tombent dans le vide !).
Avoir un point de référence pour construire ton niveau.
Éviter les erreurs liées à l’absence de sol (ex: les personnages qui tombent indéfiniment).

Le script : Supprimer la Baseplate

Voici le script que tu as fourni, commenté pour comprendre son fonctionnement :

-- Récupérer la Baseplate dans le Workspace
local baseplate = workspace:WaitForChild("Baseplate")

-- Supprimer la Baseplate
baseplate:Destroy()

Explications :

workspace:WaitForChild("Baseplate") :
- Attend que la Baseplate existe dans le Workspace avant de continuer.
- Si la Baseplate n’existe pas, le script attend qu’elle soit créée (par exemple, si elle est ajoutée plus tard).
baseplate:Destroy() :
- Supprime la Baseplate du jeu.
- Résultat : Plus de sol → les personnages et les objets tombent dans le vide !

Pourquoi est-ce important de comprendre la Baseplate ?

1. La Baseplate comme sol de base

Sans Baseplate, ton jeu n’a aucun sol par défaut.
Les joueurs et les objets tombent indéfiniment (ce qui peut être amusant pour un jeu de chute libre, mais pas pour un jeu classique !).

2. Construire ton niveau autour de la Baseplate

La Baseplate est souvent le point de départ pour construire ton monde.
Tu peux :
- Ajouter des objets (murs, plateformes, etc.) au-dessus de la Baseplate.
- Modifier sa taille pour l’adapter à ton jeu.
- Changer sa couleur pour correspondre au thème de ton jeu.

3. Cas d’usage avancés

Supprimer la Baseplate :
- Utile pour créer des jeux sans sol (ex: un jeu de vol libre, un jeu spatial).
- Attention : Si tu supprimes la Baseplate, assure-toi que ton jeu a un autre sol (ex: des plateformes flottantes).
Remplacer la Baseplate :
- Tu peux créer ton propre sol (ex: une grande Part plate) et supprimer la Baseplate par défaut.

Étape par étape : Manipuler la Baseplate dans Roblox Studio

1. Voir la Baseplate par défaut

Ouvre Roblox Studio et crée un nouveau jeu.
Dans l’arborescence (Explorer), tu verras une Baseplate sous Workspace.

2. Supprimer la Baseplate (comme dans le script)

Méthode 1 : Via le script
- Copie le script ci-dessus dans un Script (ex: dans ServerScriptService).
- Lance le jeu : la Baseplate disparaît, et tout tombe !
Méthode 2 : Manuellement
- Dans l’arborescence, fais un clic droit sur Baseplate → Delete.
- Résultat : identiques à la méthode 1.

3. Créer un sol personnalisé

Si tu veux supprimer la Baseplate mais garder un sol :

Ajoute une nouvelle Part :
- Clic droit sur Workspace → Insert Object → Part.
Redimensionne la Part :
- Dans les propriétés, modifie Size pour qu’elle soit grande (ex: Vector3.new(1000, 1, 1000)).
Positionne-la au sol :
- Modifie Position pour qu’elle soit à Y = 0 (même niveau que la Baseplate).
Supprime la Baseplate :
- Utilise le script ou supprime-la manuellement.

QCM : Vérifie ta compréhension !

À quoi sert la Baseplate dans Roblox ?
- a) À servir de sol de base pour les joueurs et les objets.
- b) À jouer des sons.
- c) À créer des personnages.

Que fait workspace:WaitForChild("Baseplate") ?
- a) Attend que la Baseplate existe dans le Workspace.
- b) Crée une nouvelle Baseplate.
- c) Supprime la Baseplate.

Que se passe-t-il si tu supprimes la Baseplate sans remplacer le sol ?
- a) Les joueurs et les objets tombent dans le vide.
- b) Le jeu plante.
- c) Rien ne change.

Comment créer un sol personnalisé après avoir supprimé la Baseplate ?
- a) Ajouter une Part plate et grande dans Workspace.
- b) Ajouter un Script.
- c) Ajouter un ClickDetector.

Idées pour aller plus loin

1. Créer un jeu sans sol

Objectif : Utiliser l’absence de sol pour un jeu de chute libre ou de vol.
Exemple :
- Supprime la Baseplate.
- Ajoute des plateformes flottantes pour que les joueurs puissent sauter de l’une à l’autre.

2. Remplacer la Baseplate par un sol personnalisé

Objectif : Avoir un sol avec une texture ou une couleur spécifique.
Comment faire ?
- Ajoute une Part plate et grande.
- Modifie sa couleur ou sa texture dans les propriétés.
- Supprime la Baseplate.

Résumé des concepts clés

Concept	Description	Exemple
Baseplate	Sol de base dans Roblox Studio.	`workspace.Baseplate`
`WaitForChild`	Attend qu’un objet existe avant de continuer.	`workspace:WaitForChild("Baseplate")`
`Destroy()`	Supprime un objet.	`baseplate:Destroy()`
Sol personnalisé	Une `Part` plate qui remplace la `Baseplate`.	`Part` avec `Size = Vector3.new(1000, 1, 1000)`

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Rétrécir avec un effet de particules

Auteur de l’article Par Patrick Gelinaud
Date de l’article 16 septembre 2026

A partir du tuto : Rétrécir puis restaurer la taille du joueur

Apprendre à utiliser ParticleEmitter pour ajouter des effets visuels spectaculaires à ton jeu Roblox. Dans ce tutoriel, on va se concentrer uniquement sur l’ajout et la personnalisation des particules pour rendre le jeu plus beau et immersif.

Pourquoi utiliser des particules ?

Les particules sont des petits effets visuels (comme des étincelles, de la fumée, des paillettes, etc.) qui peuvent :

Rendre ton jeu plus réaliste (ex: étincelles quand un joueur touche un objet magique).
Ajouter du feedback visuel (ex: montrer qu’une action a bien eu lieu).
Créer une ambiance (ex: un effet de poussière, de feu, ou de magie).

Dans ce script, on utilise un ParticleEmitter pour afficher un effet quand un joueur touche la ScalePart.

Ajouter un `ParticleEmitter` à ta `ScalePart`

Pour que le script fonctionne, tu dois ajouter un ParticleEmitter à ta ScalePart dans Roblox Studio.

Comment faire ?

Ouvre Roblox Studio et ton jeu.
Sélectionne ta ScalePart dans l’arborescence (Workspace > ScaleFolder > ScalePart).
Ajoute un ParticleEmitter :
- Clic droit sur ScalePart → Insert Object → ParticleEmitter.
- Un nouvel objet ParticleEmitter apparaît sous ScalePart.
Personnalise les particules :
- Sélectionne le ParticleEmitter dans l’arborescence.
- Dans les propriétés (à droite), tu peux modifier : Propriété Description Exemple de valeur Enabled Active/désactive l’effet. false (on l’active via le script) Texture L’apparence des particules (image). rbxassetid://242840127 (étincelles) Color La couleur des particules. Color3.fromRGB(255, 215, 0) (or) Size La taille des particules. NumberSequence.new(0.5) Lifetime Durée de vie des particules (en secondes). NumberRange.new(1, 2) Speed Vitesse des particules. NumberRange.new(5, 10) EmissionDirection Direction dans laquelle les particules sont émises. Enum.NormalId.Top (vers le haut) Rate Nombre de particules émises par seconde. 10

Exemple de configuration pour des étincelles magiques :

Propriété	Valeur	Effet
Texture	`rbxassetid://242840127`	Étincelles brillantes.
Color	`Color3.fromRGB(255, 215, 0)`	Couleur or.
Size	`NumberSequence.new({NumberSequenceKeypoint.new(0, 0.2), NumberSequenceKeypoint.new(1, 0.5)})`	Particules qui grandissent.
Lifetime	`NumberRange.new(1, 1.5)`	Les particules disparaissent après 1 à 1.5 seconde.
Speed	`NumberRange.new(3, 8)`	Vitesse aléatoire pour un effet naturel.
EmissionDirection	`Enum.NormalId.Top`	Les particules montent.
Rate	`20`	20 particules par seconde.

Comprendre le code lié aux particules

Voici la partie du script qui gère les particules (le reste du script est expliqué dans les tutoriels précédents) :

-- Dans la fonction part.Touched:Connect, après avoir modifié la taille du joueur :
local particle = part:FindFirstChildOfClass("ParticleEmitter")  -- Cherche un ParticleEmitter dans la partie

-- Appliquer la taille cible au personnage
humanoid.BodyHeightScale.Value = targetScale
humanoid.BodyWidthScale.Value = targetScale
humanoid.BodyDepthScale.Value = targetScale
humanoid.HeadScale.Value = targetScale

-- ACTIVER LES PARTICULES quand le joueur touche la partie
if particle then part.ParticleEmitter.Enabled = true end

-- Désactiver les particules après le cooldown
task.delay(COOLDOWN, function()
    cooldowns[player] = nil
    if particle then part.ParticleEmitter.Enabled = false end  -- Désactive les particules
end)

Explications :

part:FindFirstChildOfClass("ParticleEmitter")
- Cherche un objet de type ParticleEmitter dans la ScalePart.
- Si un ParticleEmitter existe, il est stocké dans la variable particle.
part.ParticleEmitter.Enabled = true
- Active l’effet de particules quand un joueur touche la ScalePart.
- Les particules apparaissent immédiatement et restent visibles tant que Enabled est à true.
part.ParticleEmitter.Enabled = false
- Désactive l’effet de particules après le COOLDOWN (1 seconde dans ce script).
- Cela évite que les particules restent actives en permanence.

Tester et personnaliser les particules

Lance le jeu dans Roblox Studio.
Touche la ScalePart :
- Ton personnage rétrécit ou grandit.
- Un effet de particules apparaît (si tu as bien configuré le ParticleEmitter).
Expérimente avec les propriétés :
- Change la texture pour des effets différents (fumée, feu, bulles, etc.).
  - Exemples d’IDs de textures :
    - Fumée : rbxassetid://242840156
    - Feu : rbxassetid://242840140
    - Bulles : rbxassetid://242840119
- Change la couleur pour correspondre au thème de ton jeu.
- Ajuste la taille et la vitesse pour un effet plus ou moins intense.

Idées pour aller plus loin avec les particules

Voici quelques idées pour améliorer ton jeu avec des ParticleEmitter :

1. Particules différentes selon l’action

Objectif : Utiliser des particules différentes quand le joueur rétrécit ou grandit.
Comment faire ?
- Ajoute deux ParticleEmitter à ta ScalePart :
  - Un pour le rétrécissement (ex: particules bleues).
  - Un pour la restauration (ex: particules vertes).
- Dans le script, active uniquement le bon ParticleEmitter selon l’action :luaCopierif originalScale then -- Restaurer : activer les particules vertes part.ParticleEmitterGreen.Enabled = true else -- Rétrécir : activer les particules bleues part.ParticleEmitterBlue.Enabled = true end

2. Particules qui suivent le joueur

Objectif : Faire apparaître des particules autour du joueur quand il rétrécit.
Comment faire ?
- Ajoute un ParticleEmitter dans le personnage du joueur (ex: dans son HumanoidRootPart).
- Rajoute cette fonction à ton script

local function addParticle(character)
	print("adding particle")
	local part = character:FindFirstChild("HumanoidRootPart")
	if not part then return end
    print("found part")
	local particle = Instance.new("ParticleEmitter")
	particle.Texture = "rbxassetid://248625108" -- mets ton ID d'image ici
	particle.Lifetime = NumberRange.new(5, 10)
	particle.Rate = 20
	particle.Speed = NumberRange.new(5, 5)
	particle.Color = ColorSequence.new(Color3.new(1, 1, 1))
	particle.Parent = part

	task.delay(COOLDOWN, function()
		particle:Destroy()
	end)

end

3. Particules avec un son

Objectif : Ajouter un son quand les particules apparaissent.
Comment faire ?
- Ajoute un objet Sound à ta ScalePart.
- Joue le son quand les particules sont activées :luaCopierlocal sound = part:FindFirstChildOfClass("Sound") if sound then sound:Play() end

QCM : Vérifie ta compréhension !

À quoi sert un ParticleEmitter dans Roblox ?
- a) À créer des effets visuels comme des étincelles ou de la fumée.
- b) À faire bouger une partie.
- c) À jouer un son.

Que fait part:FindFirstChildOfClass("ParticleEmitter") ?
- a) Crée un nouveau ParticleEmitter.
- b) Cherche un ParticleEmitter dans la part.
- c) Supprime un ParticleEmitter.

Pourquoi désactive-t-on le ParticleEmitter après le cooldown ?
- a) Pour éviter que les particules restent actives en permanence.
- b) Pour économiser de la mémoire.
- c) Pour changer la couleur des particules.

Où peut-on ajouter un ParticleEmitter dans Roblox Studio ?
- a) Dans une Part ou un Model.
- b) Dans ServerScriptService.
- c) Dans Workspace uniquement.

Quelle propriété du ParticleEmitter permet de changer l’apparence des particules ?
- a) Texture
- b) Rate
- c) Lifetime

Que fait part.ParticleEmitter.Enabled = true ?
- a) Active l’effet de particules.
- b) Désactive l’effet de particules.
- c) Change la couleur des particules.

Résumé des concepts clés

Concept	Description	Exemple dans le script
`ParticleEmitter`	Objet qui génère des effets visuels (particules).	`part:FindFirstChildOfClass("ParticleEmitter")`
`Enabled`	Propriété pour activer/désactiver l’effet.	`part.ParticleEmitter.Enabled = true`
`Texture`	Image utilisée pour les particules.	`rbxassetid://242840127`
`Color`	Couleur des particules.	`Color3.fromRGB(255, 215, 0)`
`Lifetime`	Durée de vie des particules.	`NumberRange.new(1, 1.5)`
`Rate`	Nombre de particules émises par seconde.	`20`

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Jeu de piste avec des messages personnalisés

Auteur de l’article Par Patrick Gelinaud
Date de l’article 15 septembre 2026

En cliquant sur des objets

Créer des objets (ex: des Part) dans un dossier (MessagesFolder).
Chaque objet a un message personnalisé stocké dans un attribut (Message).
Quand un joueur clique sur un objet, son personnage affiche le message dans une bulle de chat au-dessus de sa tête.

Comprendre le but du script

But :

Permettre aux joueurs de cliquer sur des objets pour afficher des messages personnalisés.
Utiliser les attributs pour stocker des données (ici, le message) directement sur les objets.
Utiliser GetDescendants pour trouver tous les ClickDetector dans un dossier, même s’ils sont imbriqués.

Concepts clés :

GetDescendants : Récupérer tous les objets enfants (y compris les enfants des enfants, etc.).
GetAttribute : Lire une donnée personnalisée stockée sur un objet (ex: un message).
ClickDetector : Détecter quand un joueur clique sur un objet.
Chat:Chat() : Afficher un message dans une bulle de chat au-dessus de la tête du joueur.

Préparer le jeu dans Roblox Studio

Pour tester le script, suis ces étapes :

Créer un dossier :
- Dans Workspace, crée un dossier nommé MessagesFolder.
Ajouter des Part :
- Ajoute plusieurs Part dans MessagesFolder.
- Pour chaque Part :
  - Ajoute un attribut Message (de type String) avec un texte différent (ex: "Bonjour !", "Salut !", "Hello !").
  - Ajoute un ClickDetector comme enfant de la Part (clic droit sur la Part → Insert Object → ClickDetector).
Ajouter le script :
- Crée un Script dans ServerScriptService et copie-y le code fourni.
Tester le jeu :
- Lance le jeu et clique sur les Part :
  - Une bulle de chat devrait apparaître au-dessus de la tête de ton personnage avec le message stocké dans l’attribut.

Comment créer un attribut pour un message personnalisé :

Le script :

Voici le script commenté pour comprendre chaque partie :

-- Récupérer le service de chat de Roblox
local Chat = game:GetService("Chat")

-- Récupérer le dossier contenant les objets cliquables
local folder = workspace:WaitForChild("MessagesFolder")

-- Parcourir TOUS les descendants du dossier (y compris les enfants des enfants, etc.)
for _, clickDetector in ipairs(folder:GetDescendants()) do
    -- Vérifier si l'objet actuel est un ClickDetector
    if not clickDetector:IsA("ClickDetector") then continue end

    -- Récupérer la partie (Part) parente du ClickDetector
    local part = clickDetector.Parent

    -- Récupérer le message stocké dans l'attribut "Message" de la partie
    local message = part and part:GetAttribute("Message")

    -- Si la partie n'a pas d'attribut "Message", on passe à l'itération suivante
    if not message then continue end

    -- Connecter une fonction au clic du ClickDetector
    clickDetector.MouseClick:Connect(function(player)
        -- Récupérer le personnage du joueur (attendre qu'il existe si nécessaire)
        local character = player.Character or player.CharacterAdded:Wait()

        -- Trouver la tête du personnage
        local head = character:FindFirstChild("Head")
        if not head then return end  -- Si pas de tête, on arrête

        -- Afficher le message dans une bulle de chat au-dessus de la tête
        Chat:Chat(head, player.Name .. " " .. message)
    end)
end

Explications détaillées

1. La puissance de `GetChildren` et `GetDescendants`

GetChildren :
- Récupère uniquement les enfants directs d’un objet.
- Exemple : Si folder contient 3 Part et que chaque Part contient un ClickDetector, folder:GetChildren() ne retournera que les 3 Part (pas les ClickDetector).
GetDescendants :
- Récupère tous les descendants (enfants, petits-enfants, etc.) d’un objet.
- Exemple : Avec la même structure, folder:GetDescendants() retournera les 3 Part et les 3 ClickDetector.
- Pourquoi c’est puissant ?
  - On peut trouver tous les objets d’un certain type (ex: tous les ClickDetector) même s’ils sont imbriqués profondément dans la hiérarchie.
  - Dans ce script, on utilise GetDescendants pour trouver tous les ClickDetector dans MessagesFolder, peu importe où ils sont placés.
Comparaison : Méthode Profondeur Exemple d’utilisation GetChildren 1 niveau Récupérer les Part directement dans folder. GetDescendants Tous niveaux Trouver tous les ClickDetector dans folder.

2. L’utilité des attributs (`GetAttribute`)

Qu’est-ce qu’un attribut ?
- Un attribut est une donnée personnalisée que tu peux attacher à un objet Roblox (ex: une Part).
- Exemple : Tu peux stocker un Message sur une Part pour savoir quel texte afficher quand un joueur clique dessus.
Pourquoi utiliser des attributs ?
- Flexibilité : Tu peux stocker n’importe quelle donnée (texte, nombre, booléen) directement sur un objet.
- Organisation : Pas besoin de créer des variables globales ou des tableaux pour associer des données à des objets.
- Performance : Les attributs sont optimisés pour être lus et modifiés rapidement.
Comment ajouter un attribut à une Part ?
- Dans Roblox Studio :
  1. Sélectionne une Part.
  2. Dans les propriétés, cherche la section Attributes.
  3. Ajoute un nouvel attribut (ex: Message de type String) et donne-lui une valeur (ex: "Bonjour !").
Dans le script :
- part:GetAttribute("Message") récupère la valeur de l’attribut Message de la Part.
- Si l’attribut n’existe pas, GetAttribute retourne nil.

3. Le fonctionnement du `ClickDetector`

Qu’est-ce qu’un ClickDetector ?
- Un objet invisible qui détecte les clics de souris sur une Part ou un Model.
- Il doit être enfant de la Part ou du Model que tu veux rendre cliquable.
Comment ça marche ?
- Quand un joueur clique sur une Part contenant un ClickDetector, l’événement MouseClick est déclenché.
- On peut connecter une fonction à cet événement pour exécuter du code quand le joueur clique.
Exemple dans le script :luaCopierclickDetector.MouseClick:Connect(function(player) -- Code exécuté quand un joueur clique sur la partie print(player.Name .. " a cliqué !") end)
- player est le joueur qui a cliqué.
- La fonction est appelée automatiquement quand un clic est détecté.
Pourquoi utiliser ClickDetector ?
- Simplicité : Pas besoin de gérer manuellement les clics avec des calculs de position.
- Précision : Roblox gère automatiquement la détection des clics, même si la Part bouge ou tourne.

4. Afficher un message dans le chat

Chat:Chat(head, message) :
- Affiche une bulle de chat au-dessus de la Head du personnage.
- head : La partie Head du personnage (où la bulle apparaîtra).
- message : Le texte à afficher (ex: "Bonjour !").
Exemple dans le script :luaCopierChat:Chat(head, player.Name .. " " .. message)
- Affiche un message comme : "Joueur1 Bonjour !".

À toi de jouer !

Modifie les messages :
- Change les valeurs des attributs Message sur tes Part et observe le résultat.
Ajoute des objets imbriqués :
- Crée un Model dans MessagesFolder, puis ajoute une Part avec un ClickDetector et un attribut Message à l’intérieur du Model.
- Vérifie que le script fonctionne toujours (grâce à GetDescendants !).
Teste avec plusieurs joueurs :
- Ouvre deux fenêtres de test et vérifie que chaque joueur voit ses propres messages.

QCM pour vérifier la compréhension

Sur `GetChildren` et `GetDescendants` :

Quelle méthode permet de récupérer tous les objets, même imbriqués, dans un dossier ?
- a) GetChildren
- b) GetDescendants
- c) GetAll
Si folder contient une Part qui contient un ClickDetector, que retourne folder:GetChildren() ?
- a) La Part et le ClickDetector.
- b) Seulement la Part.
- c) Seulement le ClickDetector.
Pourquoi utilise-t-on GetDescendants dans ce script ?
- a) Pour trouver tous les ClickDetector, même s’ils sont dans des Model imbriqués.
- b) Pour supprimer les objets.
- c) Pour changer la couleur des objets.

Sur les attributs (`GetAttribute`) :

À quoi sert part:GetAttribute("Message") ?
- a) À récupérer la valeur de l’attribut Message de la Part.
- b) À supprimer l’attribut Message.
- c) À créer un nouvel attribut.
Où peut-on ajouter un attribut à une Part dans Roblox Studio ?
- a) Dans la section Attributes des propriétés.
- b) Dans la section Script.
- c) Dans la section Model.
Que retourne GetAttribute si l’attribut n’existe pas ?
- a) nil
- b) 0
- c) Une erreur.

Sur le `ClickDetector` :

Qu’est-ce qu’un ClickDetector ?
- a) Un objet qui détecte les clics sur une Part.
- b) Un objet qui change la couleur d’une Part.
- c) Un objet qui joue un son.
Où doit-on placer un ClickDetector pour qu’il fonctionne ?
- a) Comme enfant d’une Part ou d’un Model.
- b) Dans Workspace.
- c) Dans ServerScriptService.
Que fait clickDetector.MouseClick:Connect(function(player) ... end) ?
- a) Exécute une fonction quand un joueur clique sur la Part.
- b) Supprime le ClickDetector.
- c) Change la taille de la Part.

Sur le chat :

À quoi sert Chat:Chat(head, message) ?
- a) À afficher une bulle de chat au-dessus de la tête du personnage.
- b) À envoyer un message dans le chat global.
- c) À supprimer le personnage.

Résumé des concepts appris

Concept	Explication	Exemple dans le script
`GetDescendants`	Récupère tous les descendants d’un objet (enfants, petits-enfants, etc.).	`folder:GetDescendants()`
Attributs	Données personnalisées stockées sur un objet.	`part:GetAttribute("Message")`
`ClickDetector`	Détecte les clics sur une `Part` ou un `Model`.	`clickDetector.MouseClick:Connect(...)`
`Chat:Chat`	Affiche une bulle de chat au-dessus de la tête d’un personnage.	`Chat:Chat(head, message)`
Boucles `for`	Parcourt une liste d’objets.	`for _, clickDetector in ipairs(...) do`
Conditions	Exécute du code si une condition est vraie.	`if not clickDetector:IsA("ClickDetector") then continue end`

Question pour l’enseignant :

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Rétrécir puis restaurer la taille du joueur

Auteur de l’article Par Patrick Gelinaud
Date de l’article 15 septembre 2026

A partir du tuto « Change la taille du joueur«

Quand un joueur touche une partie (ScalePart), sa taille alterne entre :

Réduction (taille = SCALEMINI).
Restauration (taille d’origine).
Un cooldown (COOLDOWN) empêche le joueur de déclencher l’effet trop souvent.
Le script gère aussi les joueurs qui quittent le jeu pour éviter les fuites de mémoire.

Comprendre le but du script

But :

Créer une partie (ScalePart) qui, quand un joueur la touche, alterne sa taille (rétrécit → restaure → rétrécit…).
Limiter la fréquence avec un cooldown (2 secondes).
Nettoyer les données des joueurs qui quittent le jeu pour éviter les bugs.

Concepts clés :

Variables : SCALEMINI, COOLDOWN.
Tableaux associatifs : cooldowns (pour le cooldown) et savedScales (pour stocker la taille d’origine).
Événements : Touched (pour détecter le contact) et PlayerRemoving (pour nettoyer les données).
Conditions : Vérifier si le joueur est déjà réduit (if originalScale then ...).

À toi de jouer !

Copie ce script dans un Script dans Roblox Studio (par exemple, dans ServerScriptService).
Crée les éléments nécessaires :
- Un dossier ScaleFolder dans Workspace.
- Une partie (Part) nommée ScalePart dans ce dossier.
Teste le jeu :
- Lance le jeu et touche la ScalePart :
  - Ton personnage rétrécit à 0.3.
  - Attends 2 secondes et touche à nouveau : ta taille est restaurée.
  - Touche une 3ème fois : tu rétrécis à nouveau.
- Teste avec 2 joueurs :
  - Vérifie que chaque joueur a son propre cooldown et sa propre taille sauvegardée.

Le script

Voici le script commenté pour comprendre chaque partie :

-- Services et objets nécessaires
local Players = game:GetService("Players")  -- Service pour gérer les joueurs

-- Récupérer la partie et son dossier parent
local folder = workspace:WaitForChild("ScaleFolder")  -- Dossier contenant la partie
local part = folder:WaitForChild("ScalePart")  -- La partie à toucher

-- Variables globales
local SCALEMINI = 0.3  -- Taille réduite appliquée au contact
local COOLDOWN = 2     -- Temps d'attente (en secondes) avant de pouvoir re-déclencher

-- Tableaux pour gérer les états des joueurs
local cooldowns = {}    -- [player] = true si le joueur est en cooldown
local savedScales = {} -- [player] = taille d'origine du joueur (si il est actuellement réduit)

-- Détecter quand un joueur touche la partie
part.Touched:Connect(function(hit)
    -- Trouver le personnage du joueur qui a touché la partie
    local character = hit:FindFirstAncestorOfClass("Model")
    local player = character and Players:GetPlayerFromCharacter(character)

    -- Ignorer si ce n'est pas un joueur (ex: un mob, un débris)
    if not player then return end

    -- VÉRIFIER LE COOLDOWN : Si le joueur est en cooldown, on arrête tout
    if cooldowns[player] then return end

    -- Trouver l'humanoïde du personnage (pour modifier sa taille)
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    if not humanoid then return end

    -- ACTIVER LE COOLDOWN pour ce joueur
    cooldowns[player] = true

    -- Récupérer la taille d'origine du joueur (si elle a été sauvegardée)
    local originalScale = savedScales[player]
    local targetScale  -- Taille cible (soit SCALEMINI, soit la taille d'origine)

    -- LOGIQUE FLIP/FLOP :
    if originalScale then
        -- Le joueur est déjà réduit : on restaure sa taille d'origine
        targetScale = originalScale
        savedScales[player] = nil  -- Supprimer la taille sauvegardée
    else
        -- Le joueur n'est pas réduit : on sauvegarde sa taille et on l'applique SCALEMINI
        savedScales[player] = humanoid.BodyHeightScale.Value
        targetScale = SCALEMINI
    end

    -- Appliquer la taille cible au personnage
    humanoid.BodyHeightScale.Value = targetScale
    humanoid.BodyWidthScale.Value = targetScale
    humanoid.BodyDepthScale.Value = targetScale
    humanoid.HeadScale.Value = targetScale

    -- Après COOLDOWN secondes, réactiver la possibilité de déclencher l'effet
    task.delay(COOLDOWN, function()
        cooldowns[player] = nil
    end)
end)

-- NETTOYAGE : Quand un joueur quitte le jeu, supprimer ses données
Players.PlayerRemoving:Connect(function(player)
    cooldowns[player] = nil
    savedScales[player] = nil
end)

Explications détaillées

1. Le mécanisme de flip/flop

Principe :
Le script alterne la taille du joueur entre :
- Réduction (SCALEMINI = 0.3) quand il touche la partie pour la première fois.
- Restauration (taille d’origine) quand il la touche à nouveau.
Comment ça marche ?
- Le tableau savedScales stocke la taille d’origine du joueur uniquement quand il est réduit.
- Si savedScales[player] existe (originalScale), cela signifie que le joueur est déjà réduit → on restaure sa taille.
- Sinon, on sauvegarde sa taille actuelle et on applique SCALEMINI.
Exemple concret :
- 1er contact : Le joueur a une taille normale (ex: 1.0). Le script sauvegarde 1.0 dans savedScales[player] et applique 0.3.
- 2ème contact : Le script voit que savedScales[player] = 1.0 existe → il restaure la taille à 1.0 et supprime savedScales[player].
- 3ème contact : savedScales[player] n’existe plus → le joueur est à nouveau réduit à 0.3.

2. Pourquoi un cooldown ?

Problème sans cooldown :
Si un joueur touche la partie plusieurs fois en une seconde, sa taille changera trop vite (ex: rétrécir → restaurer → rétrécir en 0.1 seconde).
Cela rendrait le jeu incontrôlable et peu amusant.
Solution avec cooldown :
- cooldowns[player] = true bloque le joueur pendant COOLDOWN secondes (2 secondes ici).
- Après ce délai, cooldowns[player] = nil permet au joueur de déclencher à nouveau l’effet.
Analogie :
Imagine un interrupteur qui ne peut être actionné qu’une fois toutes les 2 secondes. Le cooldown, c’est comme ce délai de sécurité !

3. Pourquoi nettoyer les tableaux quand un joueur quitte ?

Problème sans nettoyage :
Si un joueur quitte le jeu sans que ses données soient supprimées, les tableaux cooldowns et savedScales garderont des entrées inutiles.
- Conséquences :
  - Fuites de mémoire : Les tableaux grossissent indéfiniment.
  - Bugs : Si un nouveau joueur rejoint avec le même player (rare mais possible), il pourrait hériter des données du joueur précédent.
Solution avec PlayerRemoving :luaCopierPlayers.PlayerRemoving:Connect(function(player) cooldowns[player] = nil savedScales[player] = nil end)
- Quand un joueur quitte, on supprime ses entrées dans les deux tableaux.
- Cela garantit que les tableaux restent propres et efficaces.
Analogie :
C’est comme ranger ton bureau après avoir fini tes devoirs : si tu ne ranges pas, ton bureau devient un bordel, et tu ne retrouves plus rien !

4. Autres concepts importants

FindFirstAncestorOfClass("Model") :
Permet de remonter dans la hiérarchie de l’objet touché (hit) pour trouver le personnage (qui est un Model).
- Exemple : Si hit est un bras du personnage, FindFirstAncestorOfClass("Model") retourne le personnage entier.
task.delay(COOLDOWN, function() ... end) :
Exécute une fonction après un délai (COOLDOWN secondes). Ici, on réinitialise le cooldown du joueur.
Tableaux associatifs :
- cooldowns et savedScales utilisent les joueurs comme clés.
- Exemple :luaCopiersavedScales = { [Player1] = 1.0, -- Player1 a une taille d'origine de 1.0 [Player2] = nil -- Player2 n'est pas réduit }

QCM pour vérifier la compréhension

Sur le flip/flop :

Que fait le script quand un joueur touche la partie pour la première fois ?
- a) Il rétrécit le joueur et sauvegarde sa taille d’origine.
- b) Il restaure la taille du joueur.
- c) Il supprime le joueur.
Que fait le script quand un joueur touche la partie une deuxième fois ?
- a) Il rétrécit le joueur.
- b) Il restaure la taille d’origine du joueur.
- c) Il ne fait rien.
Pourquoi utilise-t-on savedScales[player] = nil quand on restaure la taille ?
- a) Pour indiquer que le joueur n’est plus réduit.
- b) Pour supprimer le joueur du jeu.
- c) Pour accélérer le jeu.

Sur le cooldown :

À quoi sert cooldowns[player] = true ?
- a) À bloquer le joueur pendant COOLDOWN secondes.
- b) À faire grandir le joueur.
- c) À changer la couleur de la partie.
Que se passe-t-il si on supprime if cooldowns[player] then return end ?
- a) Le joueur peut déclencher l’effet plusieurs fois par seconde.
- b) Le joueur ne peut plus jamais déclencher l’effet.
- c) Le jeu plantera.

Sur le nettoyage des tableaux :

Pourquoi nettoyer cooldowns et savedScales quand un joueur quitte ?
- a) Pour éviter les fuites de mémoire et les bugs.
- b) Pour faire planter le jeu.
- c) Pour accélérer le jeu.
Que fait Players.PlayerRemoving:Connect(function(player) ... end) ?
- a) Il exécute une fonction quand un joueur quitte le jeu.
- b) Il supprime tous les joueurs.
- c) Il crée un nouveau joueur.

Sur les conditions :

À quoi sert if originalScale then ... ?
- a) À vérifier si le joueur est déjà réduit (et donc doit être restauré).
- b) À vérifier si le joueur existe.
- c) À changer la couleur du joueur.

2. Ajouter un effet sonore

Objectif : Jouer un son quand le joueur rétrécit ou est restauré.
Indice :
Crée un objet Sound dans ReplicatedStorage, puis utilise sound:Play().
Exemple :

local sound = Instance.new("Sound") sound.SoundId = "rbxassetid://123456789" -- Remplace par un vrai ID de son 
sound.Parent = character.Head 
sound:Play()

Résumé des concepts appris

Concept	Explication	Exemple dans le script
Variables	Stocker des valeurs (nombres, texte, etc.).	`SCALEMINI = 0.3`, `COOLDOWN = 2`
Tableaux associatifs	Stocker des données liées à des clés (ex: joueurs).	`cooldowns[player] = true`, `savedScales[player] = 1.0`
Événements	Réagir à des actions (ex: toucher une partie, quitter le jeu).	`part.Touched:Connect`, `Players.PlayerRemoving:Connect`
Conditions	Exécuter du code seulement si une condition est vraie.	`if originalScale then ...`, `if cooldowns[player] then return end`
Fonctions asynchrones	Exécuter du code après un délai.	`task.delay(COOLDOWN, function() ... end)`
Nettoyage des données	Supprimer les données inutiles pour éviter les bugs.	`Players.PlayerRemoving:Connect(function(player) ... end)`

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Rétrécir de plus en plus le joueur

Auteur de l’article Par Patrick Gelinaud
Date de l’article 15 septembre 2026

A partir du tuto « Change la taille du joueur«

Avec un cooldown

Quand un joueur touche une partie (ScalePart), son personnage rétrécit progressivement. Un cooldown (temps d’attente) empêche le joueur de rétrécir trop vite. Le script gère aussi plusieurs joueurs en même temps.

Comprendre le but du script

But :

Créer une partie (ScalePart) qui, quand un joueur la touche, réduit la taille de son personnage.
Limiter la fréquence de rétrécissement avec un cooldown (2 secondes).
Gérer plusieurs joueurs en même temps sans bugs.

Concepts clés :

Constantes : SCALESTEP, SCALEMINI, COOLDOWN.
Tableau associatif : cooldowns pour suivre l’état de chaque joueur.
Événements : Touched pour détecter quand un joueur touche la partie.
Conditions : Vérifier si un joueur peut rétrécir (if cooldowns[player]).

Le script

Voici le script commenté pour comprendre chaque partie :

-- Services et objets nécessaires
local Players = game:GetService("Players")  -- Service pour gérer les joueurs

local folder = workspace:WaitForChild("ScaleFolder")  -- Dossier contenant la partie
local part = folder:WaitForChild("ScalePart")  -- La partie à toucher

-- Variables globales
local SCALESTEP = 0.3  -- Réduction de la taille à chaque toucher
local SCALEMINI = 0.5  -- Taille minimum (le personnage ne peut pas rétrécir en dessous)
local COOLDOWN = 2     -- Temps d'attente (en secondes) avant de pouvoir rétrécir à nouveau

-- Tableau pour gérer les cooldowns des joueurs
-- Format : cooldowns[player] = true si le joueur subi déjà un rétrécissement, nil sinon
local cooldowns = {}

-- Détecter quand un joueur touche la partie
part.Touched:Connect(function(hit)
    -- Trouver le personnage du joueur qui a touché la partie
    local character = hit:FindFirstAncestorOfClass("Model")
    local player = character and Players:GetPlayerFromCharacter(character)

    -- Ignorer si ce n'est pas un joueur (ex: un mob, un débris)
    if not player then return end

    -- VÉRIFIER LE COOLDOWN : Si le joueur est déjà en cooldown, on arrête tout
    if cooldowns[player] then return end

    -- Trouver l'humanoïde du personnage (pour modifier sa taille)
    local humanoid = character:FindFirstChildOfClass("Humanoid")

    -- Si l'humanoïde n'existe pas ou si le personnage est déjà à la taille minimum, on arrête
    if not humanoid or humanoid.HeadScale.Value <= SCALEMINI then return end

    -- ACTIVER LE COOLDOWN pour ce joueur
    cooldowns[player] = true

    -- Réduire la taille du personnage (corps + tête)
    humanoid.BodyHeightScale.Value = math.max(SCALEMINI, humanoid.BodyHeightScale.Value - SCALESTEP)
    humanoid.BodyWidthScale.Value = math.max(SCALEMINI, humanoid.BodyWidthScale.Value - SCALESTEP)
    humanoid.BodyDepthScale.Value = math.max(SCALEMINI, humanoid.BodyDepthScale.Value - SCALESTEP)
    humanoid.HeadScale.Value = math.max(SCALEMINI, humanoid.HeadScale.Value - SCALESTEP)

    -- Après COOLDOWN secondes, réactiver la possibilité de rétrécir
    task.delay(COOLDOWN, function()
        cooldowns[player] = nil  -- Supprimer le cooldown pour ce joueur
    end)
end)

À toi de jouer !

Copie ce script dans un Script dans Roblox Studio (par exemple, dans ServerScriptService).
Crée les éléments nécessaires :
- Un dossier ScaleFolder dans Workspace.
- Une partie (Part) nommée ScalePart dans ce dossier.
Teste le jeu :
- Lance le jeu avec plusieurs joueurs (ou utilise le mode test avec 2 fenêtres).
- Touche la ScalePart et observe :
  - Ton personnage rétrécit.
  - Tu ne peux pas rétrécir à nouveau avant 2 secondes.
  - Un autre joueur peut toucher la partie sans être bloqué par ton cooldown.

Explications détaillées

1. Pourquoi un cooldown ?

Problème sans cooldown :
Si un joueur ou toutes ses parties touchent le part plusieurs fois en une seconde, son personnage rétrécirait trop vite (voire disparaîtrait !).
Exemple : Sans cooldown, un joueur pourrait toucher la part 10 fois en 1 seconde et devenir minuscule instantanément.
Solution avec cooldown :
Le script utilise cooldowns[player] = true pour bloquer le rétrécissement pendant 2 secondes (COOLDOWN = 2).
Après ce délai, cooldowns[player] = nil permet au joueur de rétrécir à nouveau.
Analogie :
Imagine que tu veux boire un verre d’eau, mais tu dois attendre 2 secondes entre chaque gorgée. Le cooldown, c’est comme ce temps d’attente !

2. Pourquoi un tableau `cooldowns` ?

Gérer plusieurs joueurs :
Dans un jeu multijoueur, chaque joueur doit avoir son propre cooldown.
Exemple : Si le joueur A touche la partie, seul son cooldown est activé. Le joueur B peut toujours toucher la partie.
Tableau associatif :
cooldowns est un tableau où la clé est le player (joueur) et la valeur est true (en cooldown) ou nil (pas en cooldown).
Exemple :luaCopiercooldowns = { [Player1] = true, -- Player1 est en cooldown [Player2] = nil -- Player2 peut rétrécir }
Pourquoi pas une variable simple ?
Une variable comme isCooldown = true bloquerait tous les joueurs en même temps. Avec un tableau, chaque joueur a son propre état.

3. Autres concepts importants

math.max(SCALEMINI, value) :
Garantit que la taille ne descend jamais en dessous de SCALEMINI (0.5).
Exemple : Si humanoid.HeadScale.Value = 0.6 et SCALESTEP = 0.3, alors 0.6 - 0.3 = 0.3. Mais math.max(0.5, 0.3) retourne 0.5 (taille minimum).
FindFirstAncestorOfClass("Model") :
Permet de remonter dans la hiérarchie de l’objet touché (hit) pour trouver le personnage (qui est un Model).
task.delay(COOLDOWN, function() ... end) :
Exécute une fonction après un délai (COOLDOWN secondes). Ici, on réinitialise le cooldown du joueur.

QCM pour vérifier la compréhension

Sur le cooldown :

À quoi sert le cooldown dans ce script ?
- a) À empêcher le personnage de rétrécir trop vite.
- b) À faire grandir le personnage.
- c) À changer la couleur de la partie.
Que se passe-t-il si on supprime if cooldowns[player] then return end ?
- a) Le personnage rétrécira une fois, puis plus jamais.
- b) Le personnage rétrécira trop vite (plusieurs fois par seconde).
- c) Le jeu plantera.
Pourquoi utilise-t-on task.delay(COOLDOWN, function() ... end) ?
- a) Pour attendre 2 secondes avant de réactiver le cooldown.
- b) Pour supprimer la partie.
- c) Pour faire grandir le personnage.

Sur le tableau `cooldowns` :

Pourquoi utilise-t-on un tableau cooldowns et pas une simple variable ?
- a) Pour gérer chaque joueur individuellement.
- b) Parce que c’est plus joli.
- c) Pour économiser de la mémoire.
Que contient cooldowns[player] quand un joueur est en cooldown ?
- a) true
- b) false
- c) nil

Sur les conditions :

À quoi sert math.max(SCALEMINI, humanoid.HeadScale.Value - SCALESTEP) ?
- a) À garantir que la taille ne descend pas en dessous de SCALEMINI.
- b) À faire grandir le personnage.
- c) À changer la couleur du personnage.
Pourquoi vérifie-t-on if not humanoid or humanoid.HeadScale.Value <= SCALEMINI ?
- a) Pour empêcher le personnage de rétrécir s’il est déjà trop petit.
- b) Pour le faire grandir.
- c) Pour le faire disparaître.

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Pouvoir de transparence du joueur

Auteur de l’article Par Patrick Gelinaud
Date de l’article 11 septembre 2026

Ce script permet de rendre un joueur presque invisible quand il touche une pièce spéciale (Part).

Effet : Le corps du joueur et ses accessoires (chapeau, lunettes, etc.) deviennent transparents à 80% (presque invisibles).
Déclencheur : Quand le joueur touche la pièce Part (dans le dossier Folder).

Créer un part « JumpPart » sous un folder « JumpFolder »pour donner au joueur le pouvoir de courir plus vite :

Objets à créer dans Roblox Studio

Pour que le script fonctionne, il faut créer :

Un dossier dans le Workspace :
- Nom : Folder.
Une pièce dans ce dossier :
- Nom : Part.
- Type : BasePart (un cube, une sphère, etc.).

Crée un script dans ServerScriptService :

local heightScaleFolder = workspace:WaitForChild("Folder")
local heightScale = heightScaleFolder:WaitForChild("Part")

heightScale.Touched:Connect(function(hit)
	local character = hit:FindFirstAncestorOfClass("Model")
	
	for _, child in pairs(character:GetChildren()) do
		if child:IsA("Accessory") then
			for _, descendant in pairs(child:GetDescendants()) do
				if descendant:IsA("BasePart") or descendant:IsA("Decal") then
					descendant.Transparency = 0.8
				end
			end
		elseif child:IsA("MeshPart") then
			child.Transparency = 0.8
		end
	end

end)

Explication du code pas à pas

1. Récupérer les objets dans le Workspace

local heightScaleFolder = workspace:WaitForChild("Folder")
local heightScale = heightScaleFolder:WaitForChild("Part")

workspace:WaitForChild("Folder") :
- Attend que le dossier Folder existe dans le Workspace.
- Si le dossier n’existe pas encore, le script attend qu’il soit créé.
heightScaleFolder:WaitForChild("Part") :
- Attend que la pièce Part existe dans le dossier Folder.

💡 Pourquoi WaitForChild ?

Cela évite les erreurs si les objets ne sont pas encore créés quand le script s’exécute.

2. Détecter quand un joueur touche la pièce

heightScale.Touched:Connect(function(hit)

heightScale.Touched :
- Événement déclenché quand un objet touche la pièce Part.
hit :
- C’est l’objet qui a touché la pièce (ex: la tête, le torse ou un bras du joueur).

3. Récupérer le modèle du personnage

local character = hit:FindFirstAncestorOfClass("Model")

hit:FindFirstAncestorOfClass("Model") :
- Cherche le premier ancêtre de hit qui est un Model.
- En Roblox, le personnage d’un joueur est un Model contenant toutes ses parties (tête, bras, jambes, etc.).
- Si hit est une partie du corps (ex: Head), cette fonction renvoie le modèle du joueur (Character).

4. Parcourir toutes les parties du personnage

for _, child in pairs(character:GetChildren()) do

character:GetChildren() :
- Récupère tous les objets enfants du modèle du joueur (ex: Head, Torso, RightArm, accessoires, etc.).
pairs :
- Parcourt chaque enfant un par un (comme une boucle for en Python).
_ :
- Variable temporaire (on ne l’utilise pas, c’est juste pour la syntaxe).

5. Gérer les accessoires (chapeaux, lunettes, etc.)

if child:IsA("Accessory") then
    for _, descendant in pairs(child:GetDescendants()) do
        if descendant:IsA("BasePart") or descendant:IsA("Decal") then
            descendant.Transparency = 0.8
        end
    end
end

child:IsA("Accessory") :
- Vérifie si child est un accessoire (ex: un chapeau, des lunettes, une épée, etc.).
child:GetDescendants() :
- Récupère toutes les parties de l’accessoire (ex: les pièces qui composent le chapeau).
descendant:IsA("BasePart") or descendant:IsA("Decal") :
- Vérifie si descendant est :
  - Une pièce de base (BasePart, comme un cube).
  - Un autocollant (Decal, comme une texture sur un chapeau).
descendant.Transparency = 0.8 :
- Rend l’objet transparent à 80% (0 = invisible, 1 = opaque).
- Effet : L’accessoire devient presque invisible.

💡 Pourquoi 0.8 ?

0 = complètement invisible.

1 = complètement opaque (visible normalement).

0.8 = très transparent (presque invisible, mais encore un peu visible).

6. Gérer les parties du corps (MeshPart)

elseif child:IsA("MeshPart") then
    child.Transparency = 0.8
end

child:IsA("MeshPart") :
- Vérifie si child est une pièce avec un maillage (MeshPart).
- En Roblox, les parties du corps des joueurs modernes (comme dans R15) sont souvent des MeshPart.
child.Transparency = 0.8 :
- Rend la pièce transparente à 80%.

❓ Pourquoi seulement MeshPart ?

Dans les anciens modèles de joueurs (R6), les parties du corps étaient des Part.

Dans les modèles modernes (R15), elles sont souvent des MeshPart.

Ce script ne gère pas les Part classiques (comme Head ou Torso en R6).

Pour une invisibilité complète, il faudrait aussi gérer les Part.

Limites du script actuel

Ne gère pas les Part classiques (comme Head, Torso en R6) :
- Ces parties restent visibles.
- Pour les rendre invisibles, il faudrait ajouter :luaCopierelseif child:IsA("Part") then child.Transparency = 0.8 end
Ne gère pas les Humanoid ou autres composants :
- Certains éléments (comme les effets de lumière) ne sont pas affectés.

QCM pour tester la compréhension

Questions sur le script « Pouvoir d’invisibilité »

Que fait workspace:WaitForChild("Folder") ?
- A. Crée un dossier nommé Folder.
- B. Attend que le dossier Folder existe dans le Workspace.
- C. Supprime le dossier Folder.
- D. Change la couleur du dossier.

Que représente hit dans heightScale.Touched:Connect(function(hit) ?
- A. La pièce Part elle-même.
- B. La partie du joueur qui a touché Part (ex: la main, la tête).
- C. Le script Lua.
- D. Le dossier Folder.

À quoi sert hit:FindFirstAncestorOfClass("Model") ?
- A. Trouve la pièce Part.
- B. Trouve le modèle du personnage (le joueur entier).
- C. Trouve l’Humanoid directement.
- D. Change la taille de la pièce.

Que fait descendant.Transparency = 0.8 ?
- A. Rend l’objet complètement invisible.
- B. Rend l’objet transparent à 80% (presque invisible).
- C. Change la couleur de l’objet.
- D. Supprime l’objet.

Pourquoi utilise-t-on child:IsA("Accessory") ?
- A. Pour vérifier si child est une partie du corps.
- B. Pour vérifier si child est un accessoire (chapeau, lunettes, etc.).
- C. Pour changer la taille du joueur.
- D. Pour supprimer l’accessoire.

Que se passe-t-il si un joueur touche la pièce Part ?
- A. Le joueur disparaît complètement.
- B. Le joueur et ses accessoires deviennent presque invisibles (80% de transparence).
- C. Le joueur saute plus haut.
- D. Le joueur change de taille.

Pourquoi le script utilise MeshPart et pas Part ?
- A. Parce que Part n’existe pas en Lua.
- B. Parce que les modèles de joueurs modernes (R15) utilisent des MeshPart pour les parties du corps.
- C. Parce que MeshPart est plus rapide.
- D. Parce que c’est une erreur dans le script.

Si on veut rendre le joueur complètement invisible, que doit-on modifier ?
- A. Remplacer 0.8 par 1.
- B. Remplacer 0.8 par 0.
- C. Supprimer la ligne descendant.Transparency = 0.8.
- D. Ajouter child:Destroy().

Que faut-il ajouter pour que les parties classiques (Part) deviennent aussi invisibles ?
- A. Rien, c’est déjà géré.
- B. Ajouter elseif child:IsA("Part") then child.Transparency = 0.8 end.
- C. Ajouter child:Destroy().
- D. Changer MeshPart en BasePart.

Exercices pratiques

1. Rendre le joueur complètement invisible

Modifie le script pour que le joueur devienne 100% invisible (au lieu de 80%).

Solution :
Remplace 0.8 par 1 dans toutes les lignes Transparency.

luaCopier
descendant.Transparency = 1
child.Transparency = 1

2. Ajouter la gestion des `Part` classiques (pour R6)

Modifie le script pour qu’il rende aussi les parties classiques (Part) invisibles.

Solution :
Ajoute une condition pour les Part :

luaCopier
elseif child:IsA("Part") then
    child.Transparency = 0.8
end

3. Rendre seulement les accessoires invisibles (pas le corps)

Modifie le script pour que seuls les accessoires deviennent invisibles, mais pas le corps du joueur.

Solution :
Supprime la partie qui gère les MeshPart :

luaCopier

for _, child in pairs(character:GetChildren()) do
    if child:IsA("Accessory") then
        for _, descendant in pairs(child:GetDescendants()) do
            if descendant:IsA("BasePart") or descendant:IsA("Decal") then
                descendant.Transparency = 0.8
            end
        end
    end
end

4. Ajouter un effet temporaire (invisibilité pendant 5 secondes)

Modifie le script pour que le joueur redevienne visible après 5 secondes.

Indice :
Utilise task.wait(5) et sauvegarde les objets modifiés dans une table.
Solution :

luaCopier

heightScale.Touched:Connect(function(hit)
    local character = hit:FindFirstAncestorOfClass("Model")
    if not character then return end

    local transparentObjects = {} -- Tableau pour stocker les objets modifiés

    for _, child in pairs(character:GetChildren()) do
        if child:IsA("Accessory") then
            for _, descendant in pairs(child:GetDescendants()) do
                if descendant:IsA("BasePart") or descendant:IsA("Decal") then
                    table.insert(transparentObjects, descendant) -- Sauvegarde l'objet
                    descendant.Transparency = 0.8
                end
            end
        elseif child:IsA("MeshPart") then
            table.insert(transparentObjects, child) -- Sauvegarde l'objet
            child.Transparency = 0.8
        end
    end

    -- Attend 5 secondes
    task.wait(5)

    -- Rétablit la transparence normale
    for _, obj in pairs(transparentObjects) do
        obj.Transparency = 0
    end
end)

Si tu veux tester ces modifications ou si tu as d’autres questions, n’hésite pas !

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Change la taille du joueur

Auteur de l’article Par Patrick Gelinaud
Date de l’article 11 septembre 2026

Ce script permet de changer la taille du joueur quand il passe à travers un bloc spécial (Part).

Effet : Le joueur devient 30% de sa taille normale (très petit !).
Déclencheur : Quand le joueur touche la pièce Part (dans le dossier Folder).

Objets à créer dans Roblox Studio

Pour que le script fonctionne, il faut :

Créer un dossier dans le Workspace :
- Nom : Folder (le script attend ce dossier).
Ajouter une pièce dans ce dossier :
- Nom : Part (c’est la pièce qui déclenchera le changement de taille).
- Type : BasePart (un cube, une sphère, etc.).

Crée un script dans ServerScriptService :

local heightScaleFolder = workspace:WaitForChild("Folder")
local heightScale = heightScaleFolder:WaitForChild("Part")

heightScale.Touched:Connect(function(hit)
	local character = hit:FindFirstAncestorOfClass("Model")
        if not character then return end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if humanoid then
		humanoid.BodyHeightScale.Value = 0.3
		humanoid.BodyWidthScale.Value = 0.3
		humanoid.BodyDepthScale.Value = 0.3
		humanoid.HeadScale.Value = 0.3
	end
end)

Explication du code pas à pas

1. Récupérer les objets dans le Workspace

local heightScaleFolder = workspace:WaitForChild("Folder")
local heightScale = heightScaleFolder:WaitForChild("Part")

workspace:WaitForChild("Folder") :
- Attend que le dossier Folder existe dans le Workspace.
- Si le dossier n’existe pas encore, le script attend qu’il soit créé (au lieu de planter).
heightScaleFolder:WaitForChild("Part") :
- Attend que la pièce Part existe dans le dossier Folder.

💡 Pourquoi WaitForChild ?

En Lua/Roblox, si un objet n’existe pas encore au moment où le script s’exécute, le jeu pourrait planter.

WaitForChild évite ce problème en attendant que l’objet soit créé.

2. Détecter quand un joueur touche la pièce

heightScale.Touched:Connect(function(hit)

heightScale.Touched :
- C’est un événement qui se déclenche quand quelque chose touche la pièce Part.
hit :
- C’est l’objet qui a touché la pièce (ex: la main, la tête ou le torse du joueur).

3. Récupérer le personnage du joueur

local character = hit:FindFirstAncestorOfClass("Model")

hit:FindFirstAncestorOfClass("Model") :
- Cherche le premier ancêtre de hit qui est un Model.
- En Roblox, un joueur est représenté par un Model (son personnage entier).
- hit est une partie du corps (ex: Head, Torso), et son ancêtre est le modèle du joueur.

🔍 Exemple :
Si hit est la main du joueur (RightHand), alors :
RightHand → RightArm → Torso → Character (le Model).
La fonction trouve Character.

4. Récupérer l’Humanoid

local humanoid = character:FindFirstChildOfClass("Humanoid")

FindFirstChildOfClass("Humanoid") :
- Cherche l’Humanoid dans le modèle du joueur.
- L’Humanoid est le composant qui gère :
  - La vie du joueur.
  - Le mouvement (saut, course, etc.).
  - La taille (BodyHeightScale, BodyWidthScale, etc.).

5. Vérifier si l’Humanoid existe

if humanoid then

Pourquoi cette vérification ?
- Si humanoid est nil (n’existe pas), le script ne fait rien (return implicite).
- C’est une sécurité pour éviter les erreurs.

6. Modifier la taille du joueur

    humanoid.BodyHeightScale.Value = 0.3  -- Hauteur du corps = 30% de la normale.
    humanoid.BodyWidthScale.Value = 0.3   -- Largeur du corps = 30% de la normale.
    humanoid.BodyDepthScale.Value = 0.3  -- Profondeur du corps = 30% de la normale.
    humanoid.HeadScale.Value = 0.3         -- Taille de la tête = 30% de la normale.

BodyHeightScale : Contrôle la hauteur du corps.
BodyWidthScale : Contrôle la largeur du corps.
BodyDepthScale : Contrôle la profondeur (épaisseur) du corps.
HeadScale : Contrôle la taille de la tête.
0.3 : Le joueur sera 30% de sa taille normale (donc très petit).

💡 Pour agrandir le joueur :

Remplace 0.3 par 2 pour doubler la taille.

Remplace 0.3 par 0.5 pour réduire de moitié.

QCM pour vérifier la compréhension

Questions sur le script « Changer la taille du joueur »

Que fait workspace:WaitForChild("Folder") ?
- A. Crée un dossier nommé Folder.
- B. Attend que le dossier Folder existe dans le Workspace.
- C. Supprime le dossier Folder.
- D. Change le nom du dossier.
Que représente hit dans heightScale.Touched:Connect(function(hit) ?
- A. Le dossier Folder.
- B. La partie du joueur qui a touché la pièce Part (ex: la main, la tête).
- C. La pièce Part elle-même.
- D. Le script Lua.
À quoi sert hit:FindFirstAncestorOfClass("Model") ?
- A. Trouve la pièce Part.
- B. Trouve le modèle du personnage (le joueur entier).
- C. Trouve l’Humanoid.
- D. Change la taille de la pièce.
Que fait humanoid.BodyHeightScale.Value = 0.3 ?
- A. Réduit la hauteur du corps du joueur à 30% de sa taille normale.
- B. Augmente la hauteur de saut.
- C. Change la couleur du joueur.
- D. Supprime l’Humanoid.
Si on veut que le joueur devienne deux fois plus grand, que doit-on faire ?
- A. Mettre BodyHeightScale.Value = 0.5.
- B. Mettre BodyHeightScale.Value = 2.
- C. Mettre BodyHeightScale.Value = 0.
- D. Supprimer la ligne BodyHeightScale.
Pourquoi utilise-t-on if humanoid then ?
- A. Pour créer un Humanoid.
- B. Pour éviter les erreurs si l’Humanoid n’existe pas.
- C. Pour changer la taille de la pièce.
- D. Pour désactiver le script.

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Donne le pouvoir de sauter plus haut

Auteur de l’article Par Patrick Gelinaud
Date de l’article 9 septembre 2026

Ce script permet de donner un super-pouvoir de saut au joueur quand il touche une pièce spéciale (JumpPart).

Effet : Le joueur peut sauter beaucoup plus haut (200 unités au lieu de la valeur normale, qui est généralement autour de 7–8).
Déclencheur : Quand le joueur touche la pièce JumpPart (dans le dossier JumpFolder).

Créer un part « JumpPart » sous un folder « JumpFolder »pour donner au joueur le pouvoir de courir plus vite :

Saisie sous un script sous ServerScriptService :

local jumpFolder = workspace:waitForChild("JumpFolder")
local jumpPart = jumpFolder:waitForChild("JumpPart")

jumpPart.Touched:Connect(function(hit)
	local character = hit:FindFirstAncestorOfClass("Model")
	if not character then return end
	local humanoid = character:FindFirstChild("Humanoid")
	if humanoid then
		humanoid.JumpHeight = 200
	end
end)

Explication du code pas à pas

1. Récupérer les objets dans le Workspace

local jumpFolder = workspace:WaitForChild("JumpFolder")
local jumpPart = jumpFolder:WaitForChild("JumpPart")

workspace:WaitForChild("JumpFolder") :
- Le script attend que le dossier JumpFolder existe dans le Workspace.
- Si le dossier n’existe pas encore (par exemple, s’il est créé plus tard dans le jeu), le script ne plante pas et attend qu’il soit disponible.
jumpFolder:WaitForChild("JumpPart") :
- Attend que la pièce JumpPart existe à l’intérieur du dossier JumpFolder.

💡 Pourquoi WaitForChild ?

En Roblox, les objets peuvent être créés après que le script ait commencé à s’exécuter.

Sans WaitForChild, si JumpFolder ou JumpPart n’existe pas encore, le script planterait avec une erreur.

WaitForChild permet d’éviter cela en attendant que l’objet soit prêt.

2. Détecter quand un joueur touche la pièce

jumpPart.Touched:Connect(function(hit)

jumpPart.Touched :
- C’est un événement qui se déclenche chaque fois qu’un objet touche JumpPart.
function(hit) :
- hit est l’objet qui a touché JumpPart (par exemple, la main, la tête ou le torse du joueur).

3. Récupérer le modèle du personnage

local character = hit:FindFirstAncestorOfClass("Model")
if not character then return end

hit:FindFirstAncestorOfClass("Model") :
- Cherche le premier ancêtre de hit qui est un Model.
- Dans Roblox, un joueur est représenté par un Model (son personnage complet, avec toutes ses parties : tête, bras, jambes, etc.).
- hit est une partie du corps (ex: Head, RightArm), et son ancêtre est le modèle du joueur (Character).

🔍 Exemple concret :
Si hit est la tête du joueur (Head), alors :
Head → Character (le Model).
La fonction renvoie donc Character.

if not character then return end :
- Si character est nil (c’est-à-dire que hit n’a pas de modèle parent), le script s’arrête ici (return).
- C’est une sécurité pour éviter les erreurs si hit n’est pas une partie d’un joueur.

4. Récupérer l’Humanoid

local humanoid = character:FindFirstChild("Humanoid")

character:FindFirstChild("Humanoid") :
- Cherche l’Humanoid dans le modèle du joueur (character).
- L’Humanoid est un composant essentiel qui gère :
  - La vie du joueur.
  - Le mouvement (saut, course, etc.).
  - La taille (BodyHeightScale, etc.).
  - La hauteur de saut (JumpHeight).

5. Vérifier si l’Humanoid existe et modifier la hauteur de saut

if humanoid then
    humanoid.JumpHeight = 200
end

if humanoid then :
- Vérifie que l’Humanoid existe avant de continuer.
- Si humanoid est nil (le joueur n’a pas d’Humanoid), le script ne fait rien pour éviter les erreurs.
humanoid.JumpHeight = 200 :
- Modifie la hauteur de saut du joueur à 200 unités.
- Effet : Le joueur peut sauter beaucoup plus haut que d’habitude (la valeur normale est généralement entre 7 et 20).

💡 Pour ajuster la hauteur de saut :

humanoid.JumpHeight = 50 → Saut modéré.

humanoid.JumpHeight = 100 → Saut très haut.

humanoid.JumpHeight = 200 → Saut extrême (attention, le joueur peut sortir de la carte !).

QCM pour tester la compréhension

Questions sur le script « Pouvoir de sauter plus haut »

Que fait workspace:WaitForChild("JumpFolder") ?
- A. Crée un dossier nommé JumpFolder.
- B. Attend que le dossier JumpFolder existe dans le Workspace.
- C. Supprime le dossier JumpFolder.
- D. Change la couleur du dossier.

Que représente hit dans jumpPart.Touched:Connect(function(hit) ?
- A. La pièce JumpPart elle-même.
- B. La partie du joueur qui a touché JumpPart (ex: la main, la tête).
- C. Le script Lua.
- D. Le dossier JumpFolder.

À quoi sert hit:FindFirstAncestorOfClass("Model") ?
- A. Trouve la pièce JumpPart.
- B. Trouve le modèle du personnage (le joueur entier).
- C. Trouve l’Humanoid directement.
- D. Change la taille de la pièce.

Que fait humanoid.JumpHeight = 200 ?
- A. Réduit la taille du joueur.
- B. Donne au joueur une hauteur de saut de 200 unités.
- C. Change la couleur du joueur.
- D. Supprime l’Humanoid.

Pourquoi utilise-t-on if humanoid then ?
- A. Pour créer un Humanoid.
- B. Pour éviter les erreurs si l’Humanoid n’existe pas.
- C. Pour changer la taille de la pièce.
- D. Pour désactiver le script.

Que se passe-t-il si un joueur touche JumpPart ?
- A. Le joueur disparaît.
- B. Le joueur peut sauter beaucoup plus haut (200 unités).
- C. Le joueur devient plus petit.
- D. La pièce change de couleur.

Où doit-on placer la pièce JumpPart pour que le script fonctionne ?
- A. Dans le Workspace directement.
- B. Dans un dossier nommé JumpFolder dans le Workspace.
- C. Dans le ServerScriptService.
- D. Dans le StarterPack.

Si on veut que le joueur saute encore plus haut, que doit-on modifier ?
- A. Le nom de la pièce JumpPart.
- B. La valeur de humanoid.JumpHeight (ex: 300).
- C. La couleur de la pièce.
- D. Le nom du dossier JumpFolder

Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Donne le pouvoir de courir plus vite

Auteur de l’article Par Patrick Gelinaud
Date de l’article 9 septembre 2026

Créer un part « SpeedPart » sous un folder « SpeedFolder »pour donner au joueur le pouvoir de courir plus vite :

Saisie sous un script sous ServerScriptService :

local speedFolder = workspace:waitForChild("SpeedFolder")
local speedPart = speedFolder:waitForChild("SpeedPart")

speedPart.Touched:Connect(function(hit)
	local character = hit:FindFirstAncestorOfClass("Model")
	if not character then return end
	local humanoid = character:FindFirstChild("Humanoid")
	if humanoid then
		humanoid.WalkSpeed = 100
	end
end)

Comment fonctionne ce script ?

Ce script Lua crée un bonus de vitesse : quand un joueur touche le part, il devient plus rapide.

1. Les variables : ranger des objets dans des « boîtes »

local speedFolder = workspace:waitForChild("SpeedFolder")
local speedPart = speedFolder:waitForChild("SpeedPart")

Une variable, c’est comme une boîte avec une étiquette, dans laquelle on range quelque chose pour s’en servir plus tard.

speedFolder est une variable qui contient le dossier SpeedFolder (un dossier rangé dans le jeu, le workspace).
speedPart est une variable qui contient la partie SpeedPart, qui se trouve à l’intérieur de ce dossier.

waitForChild("...") veut dire « attends que cet objet existe, puis récupère-le ». C’est plus sûr que d’aller le chercher directement, car parfois le jeu met un petit moment à charger tous les objets.

2. L’événement Touched : réagir à un contact

speedPart.Touched:Connect(function(hit)

Touched est un événement : c’est un signal qui se déclenche automatiquement dès qu’un objet touche speedPart. Un événement, c’est comme une sonnette : elle ne fait rien toute seule, mais dès qu’on appuie dessus, ça déclenche une action.

:Connect(function(hit) ... end) veut dire « quand la sonnette retentit, exécute cette fonction ». La fonction reçoit une information appelée hit, qui est l’objet qui a touché la partie (par exemple, un bras, une jambe, un accessoire du joueur).

3. Récupérer le joueur à partir de l’objet touché

lua

local character = hit:FindFirstAncestorOfClass("Model")
if not character then return end

Le problème, c’est que hit n’est pas le joueur en entier : c’est juste un petit morceau de son corps. Alors le script remonte « dans l’arbre » pour retrouver le personnage complet :

FindFirstAncestorOfClass("Model") veut dire « cherche parmi les parents de cet objet, le premier qui est un Model » (le personnage entier est un Model).
if not character then return end veut dire « si on n’a rien trouvé, on arrête la fonction ici » (par sécurité, au cas où ce ne soit pas un joueur qui a touché la partie).

local humanoid = character:FindFirstChild("Humanoid")
if humanoid then
    humanoid.WalkSpeed = 100
end

Chaque personnage contient un objet Humanoid, qui gère ses caractéristiques (vie, vitesse, etc.). Le script le récupère avec FindFirstChild("Humanoid"), puis change sa propriété WalkSpeed (vitesse de marche) à 100, ce qui rend le joueur beaucoup plus rapide que la normale (16 par défaut).

En résumé

Toucher la partie → l’événement se déclenche → le script retrouve le joueur → il augmente sa vitesse.

À quoi sert une variable comme ‘speedPart’ dans ce script ?

Elle sert à créer une nouvelle partie dans le jeu
Elle sert uniquement à afficher du texte à l’écran
Elle supprime l’objet du jeu
Elle sert à ranger et nommer un objet pour pouvoir le réutiliser facilement

Que représente l’événement ‘Touched’ ?

Une variable qui stocke la vitesse du joueur
Une commande qui affiche un message d’erreur
Un signal qui se déclenche automatiquement quand un objet touche la partie
Un minuteur qui se déclenche toutes les secondes

Que reçoit la fonction connectée à l’événement Touched (le paramètre ‘hit’) ?

Le nom du joueur uniquement
La vitesse actuelle du joueur
L’objet exact qui est entré en contact avec la partiet
Le dossier SpeedFolder

Pourquoi utilise-t-on ‘FindFirstAncestorOfClass(« Model »)’ sur ‘hit’ ?

Pour changer la couleur du personnage
Pour remonter jusqu’au personnage complet du joueur à partir du morceau touché
Pour créer un nouveau personnage
Pour supprimer l’objet touché

Que fait la ligne ‘humanoid.WalkSpeed = 100’ ?

Elle augmente la vitesse de marche du personnage à 100
Elle téléporte le joueur
Elle donne 100 points de vie au joueur
Elle supprime l’Humanoid

A toi de créer un nouveau part pour rendre la vitesse normal au joueur

Boucle infinie pour activer l’animation aléatoirement

Création de l’animation avec TweenService

Configuration de la PowerPart

Création de l’animation avec TweenService

Paramètres de TweenService:Create :

QCM : Teste ta compréhension !

Sur les variables et la configuration :

Sur TweenService :

Sur la boucle et les événements :

Changer la taille de la partie pendant l’animation

Qu’est-ce que la Baseplate ?

Le script : Supprimer la Baseplate

Explications :

Pourquoi est-ce important de comprendre la Baseplate ?

1. La Baseplate comme sol de base

2. Construire ton niveau autour de la Baseplate

3. Cas d’usage avancés

Étape par étape : Manipuler la Baseplate dans Roblox Studio

1. Voir la Baseplate par défaut

2. Supprimer la Baseplate (comme dans le script)

3. Créer un sol personnalisé

QCM : Vérifie ta compréhension !

Idées pour aller plus loin

1. Créer un jeu sans sol

2. Remplacer la Baseplate par un sol personnalisé

Résumé des concepts clés

Pourquoi utiliser des particules ?

Ajouter un ParticleEmitter à ta ScalePart

Comment faire ?

Exemple de configuration pour des étincelles magiques :

Comprendre le code lié aux particules

Explications :

Tester et personnaliser les particules

Idées pour aller plus loin avec les particules

1. Particules différentes selon l’action

2. Particules qui suivent le joueur

3. Particules avec un son

QCM : Vérifie ta compréhension !

Résumé des concepts clés

Comprendre le but du script

Préparer le jeu dans Roblox Studio

Le script :

Explications détaillées

1. La puissance de GetChildren et GetDescendants

2. L’utilité des attributs (GetAttribute)

3. Le fonctionnement du ClickDetector

4. Afficher un message dans le chat

À toi de jouer !

QCM pour vérifier la compréhension

Sur GetChildren et GetDescendants :

Sur les attributs (GetAttribute) :

Sur le ClickDetector :

Sur le chat :

Résumé des concepts appris

Comprendre le but du script

À toi de jouer !

Le script

Explications détaillées

1. Le mécanisme de flip/flop

2. Pourquoi un cooldown ?

3. Pourquoi nettoyer les tableaux quand un joueur quitte ?

4. Autres concepts importants

QCM pour vérifier la compréhension

Sur le flip/flop :

Sur le cooldown :

Sur le nettoyage des tableaux :

Sur les conditions :

2. Ajouter un effet sonore

Résumé des concepts appris

Avec un cooldown

Comprendre le but du script

Le script

À toi de jouer !

Explications détaillées

1. Pourquoi un cooldown ?

2. Pourquoi un tableau cooldowns ?

3. Autres concepts importants

QCM pour vérifier la compréhension

Sur le cooldown :

Sur le tableau cooldowns :

Création de l’animation avec `TweenService`

Configuration de la `PowerPart`

Création de l’animation avec `TweenService`

Paramètres de `TweenService:Create` :

Sur `TweenService` :

Ajouter un `ParticleEmitter` à ta `ScalePart`

1. La puissance de `GetChildren` et `GetDescendants`

2. L’utilité des attributs (`GetAttribute`)

3. Le fonctionnement du `ClickDetector`

Sur `GetChildren` et `GetDescendants` :

Sur les attributs (`GetAttribute`) :

Sur le `ClickDetector` :

2. Pourquoi un tableau `cooldowns` ?

Sur le tableau `cooldowns` :

2. Ajouter la gestion des `Part` classiques (pour R6)