123Codage

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.

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 »

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

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

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

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

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

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

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

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

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

Introduction

Dans ce tutoriel, tu vas apprendre à programmer en Lua avec Roblox Studio en construisant un mini-jeu simple : un menu qui permet au joueur de personnaliser un bloc (une « Part ») dans le monde du jeu.

La règle de base du jeu est simple :

Le joueur appuie sur une touche pour ouvrir un menu. Dans ce menu, il peut choisir la couleur, la transparence et le matériau d’un bloc posé dans le monde.

C’est un point de départ. À la fin du tutoriel, ce sera à toi d’imaginer comment faire évoluer ce jeu (ajouter des règles, des objectifs, des points, etc.).

Tu vas construire ce projet étape par étape. Prends le temps de tester ton code à chaque étape avant de passer à la suivante : si quelque chose ne marche pas, ce n’est pas grave, c’est normal, et c’est même comme ça qu’on apprend le mieux à programmer.

Tu vas apprendre à construire une interface pour ton joueur.

---

Étape 1 : LocalScript ou Script ? Qui fait quoi ?

But : Comprendre la différence entre le code qui tourne sur ton ordinateur (le client) et le code qui tourne sur l’ordinateur central du jeu (le serveur), avant d’écrire la moindre ligne de code.

Concepts clés : Client / Serveur, LocalScript, Script

Explications

Dans un jeu Roblox, il y a toujours deux « mondes » qui communiquent :

• Le serveur : c’est l’ordinateur central qui héberge la partie pour tout le monde. Un Script placé dans ServerScriptService (ou ailleurs côté serveur) s’exécute sur le serveur. Ce qu’il fait est vu par tous les joueurs.
• Le client : c’est ton propre ordinateur (ou celui d’un autre joueur). Un LocalScript ne s’exécute que sur l’ordinateur du joueur concerné, et seulement si ce script se trouve dans certains dossiers précis : StarterPlayerScripts, StarterGui, StarterPack, PlayerGui, ou ReplicatedFirst.

Exemple concret pour notre jeu : le menu qui s’affiche à l’écran (les boutons, la barre de transparence) est une interface personnelle — chaque joueur voit son propre menu, indépendamment des autres. C’est donc un travail pour un LocalScript.

En revanche, si un jour tu veux que tous les joueurs voient le bloc changer de couleur (pas seulement celui qui a cliqué), il faudra qu’un Script côté serveur applique réellement le changement. On appelle ça la réplication, et on utilisera pour cela un RemoteEvent.

Documentation Roblox :

• Script : https://create.roblox.com/docs/reference/engine/classes/Script
• LocalScript : https://create.roblox.com/docs/reference/engine/classes/LocalScript

À toi de jouer !

1. Ouvre Roblox Studio, crée un nouveau lieu vide (Baseplate).
2. Dans l’Explorer, regarde les dossiers ServerScriptService, StarterPlayer > StarterPlayerScripts, et StarterGui. Repère bien où chacun se trouve, tu vas t’en servir tout au long du tutoriel.

QCM

1. Un LocalScript placé dans Workspace (en dehors du personnage) va-t-il s’exécuter ?

• a) Oui, toujours.
• b) Non, un LocalScript ne s’exécute que dans certains dossiers précis.
• c) Oui, mais seulement pour l’hôte de la partie.

2. Si je veux que tous les joueurs voient un bloc changer de couleur, je dois utiliser :

• a) Un LocalScript uniquement.
• b) Un Script serveur (éventuellement avec un RemoteEvent).
• c) Un print().

---

Étape 2 : Construire le menu avec trois Frames

But : Construire dans l’interface (ScreenGui) la structure visuelle de base : un cadre principal, et trois zones à l’intérieur pour les trois réglages (couleur, transparence, matériau).

Concepts clés : ScreenGui, Frame, hiérarchie des objets (parent/enfant)

Explications

En Roblox, l’interface (l’UI) se construit comme une arborescence d’objets, un peu comme des poupées russes : chaque objet est enfant d’un autre. Le point de départ obligatoire pour toute UI à l’écran est un ScreenGui.

Pour notre menu, on va créer cette hiérarchie dans l’Explorer de Studio :

StarterGui
 └─ ScreenGui
     └─ Frame                  -- le cadre principal du menu (fond, bordure)
         └─ CloseButton        -- bouton pour fermer le menu
         └─ ColorsPicker (Frame)     -- zone 1 : choix de la couleur
         └─ SliderBar (Frame)        -- zone 2 : réglage de la transparence
             └─ Fill (Frame)
             └─ Knob (Frame)
         └─ MaterialPicker (Frame)   -- zone 3 : choix du matériau

Chaque zone (ColorsPicker, SliderBar, MaterialPicker) est un Frame séparé : ça permet de les positionner indépendamment les uns des autres à l’intérieur du menu, et de les remplir chacun avec le contenu qui leur correspond (des boutons pour les deux premiers, une barre et un curseur pour le slider).

Documentation Roblox :

• Frame : https://create.roblox.com/docs/reference/engine/classes/Frame
• ScreenGui : https://create.roblox.com/docs/reference/engine/classes/ScreenGui
• Vue d’ensemble de l’UI : https://create.roblox.com/docs/ui

À toi de jouer !

1. Crée cette hiérarchie directement dans l’Explorer de Studio (clic droit > Insert Object).
2. Pour l’instant, laisse les Frame vides et de couleur unie, juste pour voir leur emplacement à l’écran. On les remplira dans les étapes suivantes.
3. Observation attendue : tu dois voir trois rectangles distincts à l’intérieur du cadre principal quand tu lances le Play Test.

Questions

1. Pourquoi sépare-t-on les trois réglages en trois Frame différents plutôt que de tout mettre dans un seul cadre ?

---

Étape 3 : Adapter l’écran à tous les terminaux — Scale vs Offset

But : Comprendre comment Roblox positionne les éléments d’interface pour qu’ils s’adaptent aussi bien à un écran de PC, de tablette que de smartphone.

Concepts clés : Scale, Offset, UDim2

Explications

Le problème : un écran de smartphone ne fait pas la même taille en pixels qu’un écran de PC. Si tu places un bouton « à 500 pixels du bord gauche », il sera bien placé sur un grand écran, mais complètement hors de l’écran sur un petit téléphone !

Pour résoudre ça, chaque taille et position en Roblox UI utilise un UDim2, qui combine deux façons de mesurer pour chaque axe :

• Scale : un pourcentage de la taille du parent (de 0 à 1). Exemple : 0.5 = la moitié de la largeur du parent, peu importe l’écran. C’est ce qui s’adapte automatiquement à toutes les tailles d’écran.
• Offset : une valeur fixe en pixels, en plus du Scale. Exemple : 10 pixels de décalage. Utile pour des détails précis (une petite marge, une icône de taille fixe) qui ne doivent pas changer selon l’écran.

Un UDim2 s’écrit comme ceci : UDim2.new(scaleX, offsetX, scaleY, offsetY).

Exemple : UDim2.new(0.5, 10, 0.5, 0) veut dire : la moitié de la largeur du parent, plus 10 pixels, et la moitié de la hauteur du parent.

Règle pratique : pour que ton menu s’adapte à tous les écrans, utilise surtout le Scale pour la taille et la position globale du menu, et réserve l’Offset pour de petits ajustements (comme on l’a fait pour compenser la largeur du Knob du slider, tu t’en souviens peut-être).

Documentation Roblox :

• UDim2 : https://create.roblox.com/docs/reference/engine/datatypes/UDim2
• Adapter l’UI à plusieurs tailles d’écran : https://create.roblox.com/docs/ui/scaling

À toi de jouer !

1. Sélectionne ton Frame principal, et regarde sa propriété Size dans les Properties.
2. Essaie de la régler en Scale pur, par exemple {0.4, 0, 0.6, 0}, puis teste le Play Test en redimensionnant la fenêtre de Studio (ou en simulant un écran de tablette avec le Device Emulator). Observe comment le menu s’adapte.
3. Remets ensuite un peu d’Offset, par exemple {0.4, 20, 0.6, 0}, et observe la différence.

QCM

1. Que vaut la largeur d’un objet avec Size = UDim2.new(0.5, 0, 1, 0) si son parent fait 800 pixels de large ?

• a) 500 pixels
• b) 400 pixels
• c) 800 pixels

2. Pourquoi n’utilise-t-on pas uniquement l’Offset pour positionner toute l’interface ?

• a) Parce que l’Offset n’existe pas vraiment dans Roblox.
• b) Parce qu’une position fixe en pixels ne s’adapte pas aux écrans de tailles différentes.
• c) Parce que c’est interdit par Roblox.

---

Étape 4 : Les coordonnées X et Y — un repère comme en maths

But : Comprendre comment repérer un point ou une taille sur l’écran, en faisant le lien avec le repère orthonormé vu en cours de mathématiques.

Concepts clés : Axes X / Y, Position, Size

Explications

Tu connais déjà le repère orthonormé en maths : un axe horizontal X, un axe vertical Y, et une origine (0, 0). En Roblox UI, c’est presque pareil, avec une différence importante :

• L’origine (0, 0) est en haut à gauche de l’écran (et non au centre comme en maths).
• L’axe X augmente vers la droite, comme en maths.
• L’axe Y augmente vers le bas (et non vers le haut !). C’est le piège classique à retenir.

(0,0) ────────────► X
  │
  │        écran
  │
  ▼
  Y

La propriété Position d’un Frame place son coin (ou son centre, selon l’AnchorPoint) à des coordonnées (X, Y) par rapport à son parent. La propriété Size fonctionne pareil, mais donne une largeur et une hauteur plutôt qu’un point.

Le rôle de l’AnchorPoint : c’est le point de référence de l’objet lui-même. Avec AnchorPoint = (0, 0) (par défaut), c’est le coin haut-gauche de l’objet qui est placé à Position. Avec AnchorPoint = (0.5, 0.5), c’est le centre de l’objet — c’est exactement pourquoi on l’a utilisé pour le Knob du slider : ça permet de centrer précisément un objet sur un point donné, plutôt que de raisonner avec son coin.

Documentation Roblox :

• Position (GuiObject) : https://create.roblox.com/docs/reference/engine/classes/GuiObject#Position
• AnchorPoint : https://create.roblox.com/docs/reference/engine/classes/GuiObject#AnchorPoint

À toi de jouer !

1. Prends ton CloseButton et change son AnchorPoint de (0, 0) à (1, 0), sans toucher à Position. Observe : le bouton doit maintenant se placer par rapport à son coin haut-droit.
2. Essaie de placer un bouton exactement au centre de son parent : AnchorPoint = (0.5, 0.5) et Position = UDim2.new(0.5, 0, 0.5, 0).

Questions

1. Si je veux qu’un objet soit collé au bord bas-droit de son parent, quel AnchorPoint dois-je utiliser ?

---

Étape 5 : Premier LocalScript — afficher et cacher l’interface

But : Écrire ton tout premier script : ouvrir le menu avec la touche X, et le fermer en cliquant sur un bouton.

Concepts clés : Variables, WaitForChild, événements (Event), fonctions, if/then

Explications

Un événement est quelque chose qui se produit à un moment précis (un clic, un appui sur une touche…) et auquel on peut « réagir » avec du code. En Lua Roblox, on se connecte à un événement avec :Connect(maFonction) : à chaque fois que l’événement se déclenche, maFonction est appelée automatiquement.

Ici, on utilise deux événements :

• TextButton.MouseButton1Click : se déclenche quand on clique sur un bouton.
• UserInputService.InputBegan : se déclenche à chaque fois qu’une touche du clavier (ou un clic, ou un appui tactile) est pressée.

On utilise aussi WaitForChild("NomDeLObjet") : ça demande au script d’attendre que l’objet existe avant de continuer, ce qui évite une erreur si l’interface n’a pas encore fini de se charger.

Code Lua

--[[
    GESTION ECRAN DU JOUEUR POUR PERSONNALISER UN BLOC
    -----------------------------------------------
    Affiche ou cache le Frame principal.
    Appui sur X -> ouvre l'écran.
    Clic sur CloseButton -> ferme l'écran.

    LocalScript à placer dans StarterPlayerScripts.
]]

-- On regroupe la touche utilisée dans une variable : si on veut la
-- changer plus tard, on ne modifie qu'une seule ligne.
local KEY_CODE_OPEN = Enum.KeyCode.X

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

local screenGui = playerGui:WaitForChild("ScreenGui")
local frame = screenGui:WaitForChild("Frame")
local close = frame:WaitForChild("CloseButton")

-- Le menu est fermé au démarrage
frame.Visible = false

-- Fonction qui va chercher le Humanoid du personnage actuel du joueur.
-- On la met dans une fonction car le personnage peut réapparaître
-- (respawn) plusieurs fois pendant la partie.
local function getHumanoid()
    local character = player.Character or player.CharacterAdded:Wait()
    return character:FindFirstChildOfClass("Humanoid") or character:WaitForChild("Humanoid")
end

local humanoid = getHumanoid()

-- À chaque fois que le personnage réapparaît, on remet humanoid à jour
player.CharacterAdded:Connect(function()
    humanoid = getHumanoid()
end)

-- Au clic sur le bouton, on ferme le menu
close.MouseButton1Click:Connect(function()
    frame.Visible = false
end)

-- Fonction appelée à CHAQUE touche pressée, sur tout le clavier
local function onKeyPress(input, gameProcessed)
    if not humanoid then return end

    -- gameProcessed est vrai si Roblox a déjà "consommé" la touche
    -- (par exemple si on est en train d'écrire dans une zone de texte).
    -- On l'ignore dans ce cas pour éviter les conflits.
    if input.KeyCode == KEY_CODE_OPEN and not gameProcessed then
        frame.Visible = true
    end
end

UserInputService.InputBegan:Connect(onKeyPress)

Documentation Roblox :

• UserInputService : https://create.roblox.com/docs/reference/engine/classes/UserInputService
• Enum.KeyCode : https://create.roblox.com/docs/reference/engine/enums/KeyCode
• TextButton.MouseButton1Click : https://create.roblox.com/docs/reference/engine/classes/GuiButton#MouseButton1Click

À toi de jouer !

1. Recopie ce script dans un LocalScript, dans StarterPlayer > StarterPlayerScripts.
2. Lance le Play Test, appuie sur la touche X : le menu doit apparaître. Clique sur CloseButton : il doit disparaître.
3. Modification à essayer : change KEY_CODE_OPEN pour une autre touche, par exemple Enum.KeyCode.E, et vérifie que ça fonctionne toujours.

QCM

1. À quoi sert WaitForChild ?

• a) À supprimer un objet.
• b) À créer un nouvel objet
• c) À attendre qu’un objet existe avant de continuer le script.

2. Pourquoi récupère-t-on le Humanoid dans une fonction plutôt qu’une seule fois au début du script ?

• a) Parce que le personnage du joueur peut réapparaître (respawn), et l’ancien Humanoid ne serait plus valide.
• b) Parce que Roblox l’exige.
• c) Parce que ça n’a aucune importance.

---

Étape 6 : Choisir la couleur d’un bloc

But : Générer automatiquement un bouton par couleur disponible, et changer la couleur du bloc au clic.

Concepts clés : Boucle for, tables (listes), Instance.new, Color3

Explications

Une table en Lua, c’est une liste d’éléments qu’on peut parcourir. Ici, on stocke une liste de couleurs disponibles, chacune avec un nom et une valeur Color3 (rouge, vert, bleu).

Une boucle for permet de répéter une action pour chaque élément d’une liste, sans avoir à recopier le code à la main pour chaque couleur. C’est un des grands intérêts de la programmation : éviter de répéter du code.

Instance.new("TextButton") crée un nouvel objet directement par le script, comme si tu l’avais glissé dans l’Explorer à la main — sauf que là, c’est automatique pour chaque couleur de la liste.

Code Lua

--[[
    SÉLECTEUR DE COULEURS
    -----------------------------------------------
    Génère un bouton par couleur. Un clic applique la couleur
    à la Part cible.

    Hiérarchie attendue : ScreenGui > Frame > ColorsPicker (Frame)
]]

local Players = game:GetService("Players")
local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

local screenGui = playerGui:WaitForChild("ScreenGui")
local frame = screenGui:WaitForChild("Frame")
local picker = frame:WaitForChild("ColorsPicker")

-- On range les boutons proprement en grille, sans les positionner un par un
local gridLayout = picker:FindFirstChildOfClass("UIGridLayout")
if not gridLayout then
    gridLayout = Instance.new("UIGridLayout")
    gridLayout.CellSize = UDim2.new(0, 80, 0, 100)
    gridLayout.CellPadding = UDim2.new(0, 8, 0, 8)
    gridLayout.Parent = picker
end

-- Le bloc que l'on va modifier
local targetPart = workspace:WaitForChild("MaPart")

-- La liste des couleurs proposées : une table de tables
-- (chaque élément est lui-même une petite table avec un nom et une couleur)
local colors = {
    {Name = "Gris", Color = Color3.fromRGB(200, 200, 200)},
    {Name = "Rouge", Color = Color3.fromRGB(255, 0, 0)},
    {Name = "Vert", Color = Color3.fromRGB(0, 255, 0)},
    {Name = "Bleu", Color = Color3.fromRGB(0, 0, 255)},
}

-- On parcourt la liste avec une boucle for, et on crée un bouton par couleur
for _, color in ipairs(colors) do
    local button = Instance.new("TextButton")
    button.Name = color.Name
    button.Size = UDim2.new(0, 80, 0, 100)
    button.Text = ""
    button.AutoButtonColor = false
    button.BackgroundColor3 = color.Color
    button.Parent = picker

    local label = Instance.new("TextLabel")
    label.Size = UDim2.new(1, 0, 0, 20)
    label.Position = UDim2.new(0, 0, 1, -20)
    label.BackgroundTransparency = 1
    label.Text = color.Name
    label.TextColor3 = Color3.fromRGB(255, 255, 255)
    label.TextScaled = true
    label.Font = Enum.Font.SourceSansBold
    label.Parent = button

    -- Au clic, on applique la couleur correspondante
    button.MouseButton1Click:Connect(function()
        targetPart.Color = color.Color
    end)
end

Documentation Roblox :

• Boucles génériques for ... in (Luau) : https://create.roblox.com/docs/luau/tables#iteration-with-generic-for
• Color3 : https://create.roblox.com/docs/reference/engine/datatypes/Color3
• Instance.new : https://create.roblox.com/docs/reference/engine/classes/Instance
• UIGridLayout : https://create.roblox.com/docs/reference/engine/classes/UIGridLayout

À toi de jouer !

1. Recopie ce script dans un LocalScript, dans StarterPlayerScripts (ou dans ScreenGui).
2. Teste : chaque couleur de la liste doit apparaître comme un bouton, et cliquer dessus doit changer la couleur du bloc.
3. Modification à essayer : ajoute une cinquième couleur à la table colors (par exemple {Name = "Jaune", Color = Color3.fromRGB(255, 255, 0)}) et vérifie qu’un bouton apparaît automatiquement, sans avoir touché au reste du script.

QCM

1. Pourquoi utilise-t-on une boucle for plutôt que de créer chaque bouton à la main ?

• a) Pour éviter de répéter le même code pour chaque couleur, et pouvoir facilement en ajouter/enlever.
• b) Parce que Roblox l’interdit autrement.
• c) Parce que ça va plus vite à l’exécution.

2. Que se passe-t-il si on ajoute un élément à la table colors ?

• a) Rien, il faut aussi modifier la boucle.
• b) Le script plante.
• c) Un nouveau bouton est automatiquement créé au prochain lancement.

---

Étape 7 : Régler la transparence avec un slider

But : Construire un curseur (slider) que le joueur peut glisser pour régler la transparence du bloc entre 0 et 1.

Concepts clés : Calculs de position, UserInputService.InputChanged, variables booléennes (true/false), math.clamp

Explications

Un booléen est une variable qui ne peut valoir que true (vrai) ou false (faux) — ici, dragging nous dit si le joueur est en train de faire glisser le curseur ou non.

Le calcul le plus important de ce script transforme la position de la souris à l’écran (en pixels) en une valeur comprise entre 0 et 1, appelée ici alpha. Cette valeur correspond exactement à ce qu’attend la propriété Transparency d’une Part : 0 = complètement opaque, 1 = complètement invisible.

math.clamp(valeur, min, max) force une valeur à rester dans un intervalle donné — indispensable ici pour ne pas dépasser 0 ou 1 si le joueur fait glisser la souris en dehors de la barre.

Code Lua

--[[
    SLIDER -> Transparence d'une Part (0 à 1)
    -----------------------------------------------
    Hiérarchie attendue : ScreenGui > Frame > SliderBar (Frame)
        SliderBar > Fill (Frame), Knob (Frame)
]]

local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

local screenGui = playerGui:WaitForChild("ScreenGui")
local frame = screenGui:WaitForChild("Frame")
local sliderBar = frame:WaitForChild("SliderBar")
local knob = sliderBar:WaitForChild("Knob")
local fill = sliderBar:FindFirstChild("Fill")

local targetPart = workspace:WaitForChild("MaPart")

local dragging = false

-- Le Knob doit être centré sur lui-même pour que le calcul soit juste
knob.AnchorPoint = Vector2.new(0.5, 0.5)

local function updateSlider(inputPosition)
    local barPos = sliderBar.AbsolutePosition.X
    local barWidth = sliderBar.AbsoluteSize.X
    local knobWidth = knob.AbsoluteSize.X

    -- On retire une demi-largeur de Knob de chaque côté pour qu'il ne
    -- déborde jamais de la barre aux extrémités
    local minX = barPos + knobWidth / 2
    local maxX = barPos + barWidth - knobWidth / 2
    if maxX <= minX then
        minX, maxX = barPos, barPos + barWidth
    end

    local clampedX = math.clamp(inputPosition, minX, maxX)
    local alpha = (clampedX - minX) / (maxX - minX)

    knob.Position = UDim2.new(alpha, knobWidth * (0.5 - alpha), knob.Position.Y.Scale, knob.Position.Y.Offset)

    if fill then
        fill.Size = UDim2.new(alpha, 0, fill.Size.Y.Scale, fill.Size.Y.Offset)
    end

    targetPart.Transparency = alpha
    return alpha
end

knob.InputBegan:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        dragging = true
    end
end)

UserInputService.InputEnded:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        dragging = false
    end
end)

UserInputService.InputChanged:Connect(function(input)
    if dragging and (input.UserInputType == Enum.UserInputType.MouseMovement
        or input.UserInputType == Enum.UserInputType.Touch) then
        updateSlider(input.Position.X)
    end
end)

Documentation Roblox :

• math.clamp (Luau) : https://create.roblox.com/docs/luau/numbers#numeric-clamp
• AbsoluteSize / AbsolutePosition : https://create.roblox.com/docs/reference/engine/classes/GuiObject#AbsoluteSize
• InputChanged : https://create.roblox.com/docs/reference/engine/classes/UserInputService#InputChanged

À toi de jouer !

1. Crée SliderBar, avec Fill et Knob à l’intérieur, dans le Frame principal.
2. Recopie le script, teste en faisant glisser le Knob : le bloc doit devenir de plus en plus transparent.
3. Modification à essayer : affiche le pourcentage actuel dans un TextLabel à côté du slider (indice : utilise la valeur alpha retournée par updateSlider, et convertis-la en pourcentage avec math.floor(alpha * 100)).

QCM

1. Que fait math.clamp(alpha, 0, 1) si alpha vaut 1.3 ?

• a) Il renvoie 1, la valeur maximale autorisée.
• b) Il renvoie 1.3 sans rien changer.
• c) Il provoque une erreur.

2. Pourquoi le Knob doit-il avoir un AnchorPoint de (0.5, 0.5) ?

• a) Pour des raisons esthétiques uniquement.
• b) Ce n’est pas nécessaire, c’est une erreur dans le script
• c) Pour que le calcul de position centre bien le Knob par rapport au calcul d’alpha, sans qu’il déborde des bords de la barre.

---

Étape 8 : Choisir le matériau d’un bloc, avec un aperçu 3D

But : Générer un bouton par matériau, avec un véritable aperçu 3D du rendu du matériau (bois, métal, verre…) directement dans le bouton.

Concepts clés : ViewportFrame, WorldModel, Enum.Material, CFrame

Explications

Un ViewportFrame est un objet d’interface un peu spécial : c’est une fenêtre vers une petite scène 3D indépendante, avec sa propre caméra et ses propres objets, sans lien avec le vrai monde du jeu. C’est ce qui permet d’afficher un petit cube avec le matériau réellement appliqué, plutôt qu’une simple image.

On utilise un WorldModel pour contenir les objets 3D du ViewportFrame, une PointLight pour bien voir le relief du matériau, et une Camera pour définir sous quel angle on regarde le cube.

Code Lua

--[[
    SÉLECTEUR DE MATÉRIAU AVEC APERÇU 3D
    -----------------------------------------------
    Hiérarchie attendue : ScreenGui > Frame > MaterialPicker (Frame)
]]

local Players = game:GetService("Players")
local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

local screenGui = playerGui:WaitForChild("ScreenGui")
local frame = screenGui:WaitForChild("Frame")
local picker = frame:WaitForChild("MaterialPicker")

local gridLayout = picker:FindFirstChildOfClass("UIGridLayout")
if not gridLayout then
    gridLayout = Instance.new("UIGridLayout")
    gridLayout.CellSize = UDim2.new(0, 80, 0, 100)
    gridLayout.CellPadding = UDim2.new(0, 8, 0, 8)
    gridLayout.Parent = picker
end

local targetPart = workspace:WaitForChild("MaPart")

local materials = {
    Enum.Material.Plastic,
    Enum.Material.Wood,
    Enum.Material.Metal,
    Enum.Material.Grass,
    Enum.Material.Brick,
    Enum.Material.Concrete,
    Enum.Material.Glass,
    Enum.Material.Ice,
}

-- Construit la petite scène 3D d'aperçu pour un matériau donné
local function createPreview(material)
    local viewport = Instance.new("ViewportFrame")
    viewport.Size = UDim2.new(1, 0, 1, -20)
    viewport.BackgroundTransparency = 1
    viewport.BorderSizePixel = 0

    local worldModel = Instance.new("WorldModel")
    worldModel.Parent = viewport

    local sample = Instance.new("Part")
    sample.Size = Vector3.new(2, 2, 2)
    sample.Material = material
    sample.Color = Color3.fromRGB(255, 255, 255)
    sample.Anchored = true
    sample.Parent = worldModel

    local light = Instance.new("PointLight")
    light.Brightness = 3
    light.Range = 20
    light.Parent = sample

    local camera = Instance.new("Camera")
    camera.CFrame = CFrame.new(Vector3.new(3, 3, 3), sample.Position)
    viewport.CurrentCamera = camera
    camera.Parent = viewport

    return viewport
end

for _, material in ipairs(materials) do
    local button = Instance.new("TextButton")
    button.Name = material.Name
    button.Size = UDim2.new(0, 80, 0, 100)
    button.Text = ""
    button.AutoButtonColor = false
    button.BackgroundTransparency = 1
    button.Parent = picker

    local preview = createPreview(material)
    preview.Parent = button

    local label = Instance.new("TextLabel")
    label.Size = UDim2.new(1, 0, 0, 20)
    label.Position = UDim2.new(0, 0, 1, -20)
    label.BackgroundTransparency = 1
    label.Text = material.Name
    label.TextColor3 = Color3.fromRGB(255, 255, 255)
    label.TextScaled = true
    label.Font = Enum.Font.SourceSansBold
    label.Parent = button

    button.MouseButton1Click:Connect(function()
        targetPart.Material = material

        for _, other in ipairs(picker:GetChildren()) do
            if other:IsA("TextButton") then
                other.BackgroundColor3 = Color3.fromRGB(60, 60, 60)
            end
        end
        button.BackgroundColor3 = Color3.fromRGB(0, 140, 255)
    end)
end

Documentation Roblox :

• ViewportFrame : https://create.roblox.com/docs/reference/engine/classes/ViewportFrame
• Enum.Material : https://create.roblox.com/docs/reference/engine/enums/Material
• CFrame : https://create.roblox.com/docs/reference/engine/datatypes/CFrame

À toi de jouer !

1. Crée MaterialPicker dans le Frame principal, recopie le script.
2. Teste : chaque matériau doit s’afficher avec un vrai aperçu 3D, et cliquer dessus doit changer le matériau du bloc.
3. Modification à essayer : ajoute Enum.Material.Neon à la liste materials, et observe le rendu très différent (le néon « brille » même sans lumière).

Questions

1. Pourquoi utilise-t-on un ViewportFrame plutôt qu’une simple image pour chaque matériau ?

---

Conclusion

Mets-toi maintenant à la place d’un joueur qui découvre ton jeu pour la première fois : est-ce que le menu est facile à comprendre sans explication ? Est-ce qu’il sait tout de suite comment ouvrir le menu, changer les réglages, et le fermer ?

Puis imagine ce même joueur, une semaine plus tard, devenu un expert de ton jeu : qu’est-ce qui pourrait encore le surprendre ou l’amuser ? Un nouveau matériau à débloquer ? Un défi à relever ?

N’hésite pas à partager ton jeu avec tes camarades pour qu’ils le testent, et note leurs retours : c’est souvent en observant quelqu’un d’autre jouer qu’on repère les points à améliorer. Et surtout, continue à le faire évoluer — ajoute des règles, des niveaux, des surprises. C’est ton jeu maintenant !