Auteur/autrice : Patrick Gelinaud

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 :

1. Objet à animer : powerPart (la partie à animer).
2. 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).
3. 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 :

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

2. 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 :

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

5. 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.

6. 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 :

7. 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.

8. 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)

9. 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.

10. 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)

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 :

1. 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).
2. 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 :

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

QCM : Vérifie ta compréhension !

1. À 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.

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

3. 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.

4. 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)

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 ?

1. Ouvre Roblox Studio et ton jeu.
2. Sélectionne ta ScalePart dans l’arborescence (Workspace > ScaleFolder > ScalePart).
3. Ajoute un ParticleEmitter :
   • Clic droit sur ScalePart → Insert Object → ParticleEmitter.
   • Un nouvel objet ParticleEmitter apparaît sous ScalePart.
4. 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 :

1. part:FindFirstChildOfClass("ParticleEmitter")
   • Cherche un objet de type ParticleEmitter dans la ScalePart.
   • Si un ParticleEmitter existe, il est stocké dans la variable particle.
2. 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.
3. 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

1. Lance le jeu dans Roblox Studio.
2. Touche la ScalePart :
   • Ton personnage rétrécit ou grandit.
   • Un effet de particules apparaît (si tu as bien configuré le ParticleEmitter).
3. 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 !

1. À 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.

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

3. 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.

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

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

6. 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

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 :

1. GetDescendants : Récupérer tous les objets enfants (y compris les enfants des enfants, etc.).
2. GetAttribute : Lire une donnée personnalisée stockée sur un objet (ex: un message).
3. ClickDetector : Détecter quand un joueur clique sur un objet.
4. 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 :

1. Créer un dossier :
   • Dans Workspace, crée un dossier nommé MessagesFolder.
2. 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).
3. Ajouter le script :
   • Crée un Script dans ServerScriptService et copie-y le code fourni.
4. 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 !

1. Modifie les messages :
   • Change les valeurs des attributs Message sur tes Part et observe le résultat.
2. 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 !).
3. 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 :

1. Quelle méthode permet de récupérer tous les objets, même imbriqués, dans un dossier ?
   • a) GetChildren
   • b) GetDescendants
   • c) GetAll
     
2. 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.
     
3. 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) :

4. À 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.
     
5. 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.
     
6. Que retourne GetAttribute si l’attribut n’existe pas ?
   • a) nil
   • b) 0
   • c) Une erreur.
     

Sur le ClickDetector :

7. 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.
     
8. 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.
     
9. 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 :

10. À 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 :

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 !

1. Copie ce script dans un Script dans Roblox Studio (par exemple, dans ServerScriptService).
2. Crée les éléments nécessaires :
   • Un dossier ScaleFolder dans Workspace.
   • Une partie (Part) nommée ScalePart dans ce dossier.
3. 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 :

1. 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.
     
2. 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.
     
3. 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 :

4. À quoi sert cooldowns[player] = true ?
   • a) À bloquer le joueur pendant COOLDOWN secondes.
   • b) À faire grandir le joueur.
   • c) À changer la couleur de la partie.
     
5. 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 :

6. 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.
     
7. 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 :

8. À 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)

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 !

1. Copie ce script dans un Script dans Roblox Studio (par exemple, dans ServerScriptService).
2. Crée les éléments nécessaires :
   • Un dossier ScaleFolder dans Workspace.
   • Une partie (Part) nommée ScalePart dans ce dossier.
3. 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 :

1. À 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.
     
2. 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.
     
3. 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 :

4. 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.
     
5. Que contient cooldowns[player] quand un joueur est en cooldown ?
   • a) true
   • b) false
   • c) nil

Sur les conditions :

6. À 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.
     
7. 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.
     

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 :

1. Un dossier dans le Workspace :
   • Nom : Folder.
2. 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

1. 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
2. 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é »

1. 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.

2. 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.

3. À 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.

4. 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.

5. 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.

6. 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.

7. 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.

8. 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().

9. 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 !

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 :

1. Créer un dossier dans le Workspace :
   • Nom : Folder (le script attend ce dossier).
2. 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 »

1. 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.
2. 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.
3. À 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.
4. 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.
5. 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.
6. 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.