123Codage

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

Renommer le script leaderstats :

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

local players = game:GetService("Players")

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

Si tu lances ton jeu une barre s’affiche :

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

Rajoute à ton script un score à afficher :

local players = game:GetService("Players")

players.PlayerAdded:Connect(function(player)

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

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

end)

Le score s’affiche si tu lances ton jeu :

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

local clickDetector = script.Parent.ClickDetector

clickDetector.MouseClick:Connect(function(player)

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

end)

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

local myPart = script.Parent


myPart.Touched:Connect(function(hit)

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

end)

Les checkpoints sont des points de sauvegarde dans un jeu. Quand un joueur touche un checkpoint, sa position est enregistrée. Si le joueur meurt ou revient dans la partie, il réapparaît au dernier checkpoint touché.

Dans ce script, les checkpoints ne sont pas ordonnés : le joueur peut les toucher dans n’importe quel ordre.

1. Comment parcourir les checkpoints dans un dossier avec une boucle for.
2. Comment stocker le dernier checkpoint pour chaque joueur.
3. Comment détecter quand un joueur revient dans la partie et le téléporter à son dernier checkpoint.

Préparation dans Roblox Studio

Pour tester ce script, suis ces étapes :

1. Créer un dossier pour les checkpoints :
   • Dans Workspace, crée un dossier nommé CheckpointsFolder.
2. Ajouter des checkpoints :
   • Ajoute plusieurs Part dans CheckpointsFolder.
   • Nomme-les comme tu veux (ex: Checkpoint1, Checkpoint2, etc.).
   • Place-les à différents endroits dans ton jeu.
3. Ajouter le script :
   • Crée un Script dans ServerScriptService et copie le code suivant.
   • Le script supprime automatiquement la Baseplate pour éviter les interférences.
   • Si tu veux garder un sol, ajoute une Part plate dans Workspace.

Voici le script commenté pour comprendre :

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

-- Récupérer la Baseplate et le dossier des checkpoints
local baseplate = workspace:WaitForChild("Baseplate")
local checkpointsFolder = workspace:WaitForChild("CheckpointsFolder")

-- Tableau pour stocker le dernier checkpoint de chaque joueur
-- Format : playerCheckpoints[userId] = CFrame du dernier checkpoint
local playerCheckpoints = {}

-- Supprimer la Baseplate (pour éviter les interférences)
baseplate:Destroy()

-- Fonction appelée quand un personnage est ajouté (ex: quand un joueur respawn)
local function onCharacterAdded(character, userId)
    -- Récupérer le dernier checkpoint du joueur
    local storedCFrame = playerCheckpoints[userId]

    -- Si le joueur n'a pas de checkpoint enregistré, on ne fait rien
    if not storedCFrame then
        return
    end

    -- Attendre que le HumanoidRootPart existe (partie principale du personnage)
    local humanoidRootPart = character:WaitForChild("HumanoidRootPart")

    -- Ajouter un petit décalage aléatoire pour éviter que les joueurs spawnent au même endroit
    local offset = Vector3.new(math.random(-1, 1), 4, math.random(-1, 1))

    -- Téléporter le joueur à son dernier checkpoint + décalage
    humanoidRootPart.CFrame = storedCFrame + offset
end

-- Fonction appelée quand un joueur touche un checkpoint
local function onTouched(checkpoint, hit)
    -- Récupérer le personnage qui a touché le checkpoint
    local character = hit.Parent

    -- Vérifier si c'est bien un personnage avec un Humanoid (un joueur)
    if not character or not character:FindFirstChildOfClass("Humanoid") then
        return
    end

    -- Récupérer le joueur associé au personnage
    local player = Players:GetPlayerFromCharacter(character)
    if not player then
        return
    end

    -- Récupérer l'ID unique du joueur
    local userId = player.UserId

    -- Connecter l'événement CharacterAdded UNE SEULE FOIS par joueur
    -- Cela évite de connecter plusieurs fois le même événement
    if not playerCheckpoints[userId] then
        player.CharacterAdded:Connect(function(newCharacter)
            onCharacterAdded(newCharacter, userId)
        end)
    end

    -- Stocker le CFrame (position + rotation) du checkpoint pour ce joueur
    playerCheckpoints[userId] = checkpoint.CFrame
end

-- Parcourir tous les checkpoints dans le dossier CheckpointsFolder
for _, checkpoint in ipairs(checkpointsFolder:GetChildren()) do
    -- Vérifier si l'objet est une BasePart (ex: une Part)
    if not checkpoint:IsA("BasePart") then continue end

    -- Configurer le checkpoint
    checkpoint.Anchored = true          -- Empêcher le checkpoint de bouger
    checkpoint.CanCollide = true        -- Permettre les collisions
    checkpoint.Transparency = 0.5       -- Rendre le checkpoint semi-transparent
    checkpoint.Material = Enum.Material.Neon  -- Matériau Neon pour un effet lumineux
    checkpoint.BrickColor = BrickColor.new("Bright blue")  -- Couleur bleue vive

    -- Connecter l'événement Touched pour détecter quand un joueur touche le checkpoint
    checkpoint.Touched:Connect(function(hit)
        onTouched(checkpoint, hit)
    end)
end

Le script supprime automatiquement la Baseplate.

1. La boucle for pour parcourir les checkpoints

for _, checkpoint in ipairs(checkpointsFolder:GetChildren()) do
    if not checkpoint:IsA("BasePart") then continue end
    -- Configurer le checkpoint...
end

• checkpointsFolder:GetChildren() :
  • Récupère tous les enfants directs du dossier CheckpointsFolder.
  • Retourne une liste de tous les objets dans ce dossier.
• ipairs(...) :
  • Parcourt la liste des enfants un par un.
  • _ est une variable temporaire (non utilisée) qui représente l’index (position dans la liste).
  • checkpoint est l’objet actuel dans la boucle (ex: une Part).
• if not checkpoint:IsA("BasePart") then continue end :
  • Vérifie si checkpoint est une BasePart (ex: une Part).
  • Si ce n’est pas le cas (ex: un Folder, un Script), on passe à l’itération suivante avec continue.
• Pourquoi utiliser GetChildren ?
  • On veut trouver tous les checkpoints dans le dossier CheckpointsFolder.
  • GetChildren est plus rapide que GetDescendants car on ne cherche que les enfants directs (pas les petits-enfants).

2. Stocker le checkpoint pour le joueur

local playerCheckpoints = {}  -- Tableau pour stocker les checkpoints

-- Dans la fonction onTouched :
playerCheckpoints[userId] = checkpoint.CFrame

• playerCheckpoints :
  • C’est un tableau associatif où :
    • Clé = userId (l’ID unique du joueur).
    • Valeur = CFrame du dernier checkpoint touché par le joueur.
• checkpoint.CFrame :
  • Le CFrame est une propriété qui stocke la position et la rotation d’un objet.
  • Quand un joueur touche un checkpoint, on stocke son CFrame dans playerCheckpoints[userId].
• Pourquoi utiliser userId comme clé ?
  • Chaque joueur a un ID unique (UserId).
  • Cela permet de stocker un checkpoint différent pour chaque joueur.

3. Détecter quand le joueur revient dans la partie

-- Dans la fonction onTouched :
if not playerCheckpoints[userId] then
    player.CharacterAdded:Connect(function(newCharacter)
        onCharacterAdded(newCharacter, userId)
    end)
end

-- Fonction onCharacterAdded :
local function onCharacterAdded(character, userId)
    local storedCFrame = playerCheckpoints[userId]
    if not storedCFrame then return end

    local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
    local offset = Vector3.new(math.random(-1, 1), 4, math.random(-1, 1))
    humanoidRootPart.CFrame = storedCFrame + offset
end

• player.CharacterAdded:Connect(...) :
  • Événement déclenché quand un joueur respawn (réapparaît après être mort ou avoir rejoint le jeu).
  • On connecte une seule fois cet événement par joueur (grâce à if not playerCheckpoints[userId]).
• onCharacterAdded :
  • Cette fonction est appelée quand un joueur réapparaît.
  • Elle téléporte le joueur à son dernier checkpoint (storedCFrame).
  • offset : Ajoute un petit décalage aléatoire pour éviter que plusieurs joueurs spawnent au même endroit.
• WaitForChild("HumanoidRootPart") :
  • Attend que le HumanoidRootPart (partie centrale du personnage) existe avant de le téléporter.
  • Cela évite les erreurs si le personnage n’est pas encore complètement chargé.

QCM : Teste ta compréhension !

Sur la boucle for et GetChildren :

1. Que fait checkpointsFolder:GetChildren() ?
   • a) Récupère tous les enfants directs du dossier CheckpointsFolder.
   • b) Récupère tous les descendants (enfants, petits-enfants, etc.) du dossier.
   • c) Supprime tous les enfants du dossier.

2. Pourquoi utilise-t-on if not checkpoint:IsA("BasePart") then continue end ?
   • a) Pour ignorer les objets qui ne sont pas des BasePart (ex: des Folder).
   • b) Pour supprimer les checkpoints.
   • c) Pour changer la couleur des checkpoints.

3. Que contient la variable checkpoint dans la boucle for ?
   • a) Un objet (ex: une Part) dans le dossier CheckpointsFolder.
   • b) Un nombre.
   • c) Un joueur.

Sur le stockage des checkpoints :

4. À quoi sert playerCheckpoints[userId] = checkpoint.CFrame ?
   • a) Stocker la position et la rotation du checkpoint pour un joueur.
   • b) Supprimer le checkpoint.
   • c) Changer la taille du checkpoint.

5. Pourquoi utilise-t-on userId comme clé dans playerCheckpoints ?
   • a) Parce que chaque joueur a un ID unique, ce qui permet de stocker un checkpoint différent pour chaque joueur.
   • b) Parce que c’est plus rapide.
   • c) Parce que c’est obligatoire.

6. Que fait playerCheckpoints[userId] si userId n’existe pas dans le tableau ?
   • a) Retourne nil.
   • b) Crée une erreur.
   • c) Retourne 0.

Sur la détection du retour du joueur :

7. À quoi sert player.CharacterAdded:Connect(...) ?
   • a) Exécuter une fonction quand un joueur réapparaît dans la partie.
   • b) Créer un nouveau personnage.
   • c) Supprimer le personnage.

8. Pourquoi utilise-t-on WaitForChild("HumanoidRootPart") ?
   • a) Pour attendre que le HumanoidRootPart existe avant de le téléporter.
   • b) Pour supprimer le HumanoidRootPart.
   • c) Pour changer la couleur du personnage.

9. Que fait humanoidRootPart.CFrame = storedCFrame + offset ?
   • a) Téléporte le joueur à son dernier checkpoint avec un petit décalage aléatoire.
   • b) Fait grandir le joueur.
   • c) Supprime le joueur.

10. Pourquoi ajoute-t-on un offset aléatoire ?
    • a) Pour éviter que plusieurs joueurs spawnent exactement au même endroit.
    • b) Pour rendre le jeu plus difficile.
    • c) Pour changer la taille du joueur.

Idées pour aller plus loin

1. Ajouter un effet visuel aux checkpoints

• Objectif : Faire clignoter les checkpoints quand un joueur les touche.

2. Ajouter un son quand un checkpoint est touché

• Objectif : Jouer un son quand un joueur touche un checkpoint.

Comment gérer un part de pouvoir aléatoire : Aléatoirement, le part change de couleur et peut être traversé pour acquérir un pouvoir puis redevient compact sans laisser la possibilité d’acquérir un nouveau pouvoir.

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

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 :

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

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

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.