boost – 123Codage

Ici, tu vas apprendre à coder des boosts pour rendre ton personnage plus petit, transparent, plus rapide ou capable de sauter plus haut.
Tu vas découvrir comment modifier ton personnage avec des scripts simples en Lua, le langage de Roblox.

Créer une base avec 4 pièces (parts) dans Roblox. Chaque pièce active ou désactive un boost (ex. : transparence, taille réduite, saut plus haut, course plus rapide) quand le joueur la traverse.

Ce que tu vas apprendre :

Lire la structure hiérarchique sous workspace :
- Utiliser une boucle for pour parcourir toutes les pièces dans le jeu.
- Reconnaître chaque part grâce à son nom (ex. : MoreJump, MoreSpeed, etc.).
Gérer l’événement de collision (Touched) :
- Détecter quand un joueur touche une part avec part.Touched:Connect().
- Vérifier si l’objet qui touche est bien un joueur (en cherchant un Humanoid).
Appliquer ou retirer le boost :
- Utiliser des conditions (if/else) pour savoir quel boost activer en fonction du nom de la part.
  - local existingFolder = humanoid:FindFirstChild(« Speed »)
    if existingFolder then
- Modifier les propriétés du joueur (ex. : Humanoid.WalkSpeed pour la vitesse, Humanoid.JumpPower pour le saut).
Gérer un cooldown :
- Ajouter un délai (task.delay(COOLDOWN_DURATION)) pour éviter que le joueur active le boost trop souvent.
- Utiliser une table (activeCooldowns) pour suivre les joueurs en cooldown.

Résultat :
Un système où chaque part active/désactive un boost différent, avec une gestion propre des collisions et des délais

Ce script exemple permet de créer des zones spéciales dans Roblox qui, lorsqu’un joueur les touche, augmentent temporairement sa hauteur de saut (par exemple, pour sauter plus haut). Après avoir touché la zone, le joueur doit attendre un certain temps (COOLDOWN_DURATION) avant de pouvoir réutiliser l’effet.

Objets à créer dans le Workspace de Roblox

Pour que le script fonctionne, il faut créer ces éléments dans Roblox Studio :

Un dossier nommé ZonesBoost dans le Workspace :
- C’est ici que seront placées toutes les zones de boost.
- Comment faire : Dans l’onglet Explorer, cliquez droit sur Workspace → Insert Object → Folder → Renommez-le en ZonesBoost.
Des pièces (Parts) nommées MoreJump dans le dossier ZonesBoost :
- Ce sont les zones que le joueur pourra toucher pour activer le boost.
- Comment faire :
  - Insérez une Part (cliquez droit sur ZonesBoost → Insert Object → Part).
  - Renommez-la en MoreJump.
  - Ajustez sa taille et sa position pour qu’elle soit visible et accessible dans le jeu.
  - Répétez pour ajouter plusieurs zones si besoin.

Exemple de script pour sauter plus haut

local ZONES_FOLDER = workspace:WaitForChild("ZonesBoost")
local JUMP_MAX = 80
local COOLDOWN_DURATION = 1  -- en secondes
local activeCooldowns = {}  -- [character] = true si en cooldown

-- Parcourir uniquement les enfants directs du dossier (pas les descendants)
for _, part in ipairs(ZONES_FOLDER:GetDescendants()) do
	if not (part:IsA("BasePart") and part.Name == "MoreJump") then continue end

	part.Touched:Connect(function(hit)
		-- Vérifier que l'objet qui a touché est bien un personnage
		local character = hit.Parent
		if not character then return end

		local humanoid = character:FindFirstChildOfClass("Humanoid")
		if not humanoid then return end

		-- Vérifier le cooldown
		if activeCooldowns[character] then return end
		activeCooldowns[character] = true

		-- Sauvegarder ou restaurer la hauteur de saut
		local jumpValue = humanoid:FindFirstChild("Jump")
		if jumpValue then
			humanoid.JumpHeight = jumpValue.Value
			jumpValue:Destroy()
		else
			jumpValue = Instance.new("IntValue")
			jumpValue.Name = "Jump"
			jumpValue.Value = humanoid.JumpHeight
			jumpValue.Parent = humanoid
			humanoid.JumpHeight = JUMP_MAX
		end

		-- Réinitialiser le cooldown après le délai
		task.delay(COOLDOWN_DURATION, function()
			activeCooldowns[character] = nil
		end)
	end)
end

Déclaration des variables globales

local ZONES_FOLDER = workspace.ZonesBoost
local JUMP_MAX = 80
local COOLDOWN_DURATION = 1 -- secondes
local activeCooldowns = {} -- [character] = true pendant le cooldown

ZONES_FOLDER : Référence au dossier ZonesBoost dans le Workspace. C’est ici que le script va chercher les zones de boost.
JUMP_MAX : La hauteur de saut maximale (80) appliquée quand le joueur touche une zone.
COOLDOWN_DURATION : Temps d’attente (1 seconde) avant que le joueur puisse réutiliser le boost.
activeCooldowns : Une table (comme un dictionnaire) qui stocke si un joueur est en cooldown ou non.
- Exemple : activeCooldowns[character] = true signifie que le joueur ne peut pas encore réutiliser le boost.

Récupérer les objets du Workspace

for _, part in ipairs(folder:GetDescendants()) do

ZONES_FOLDER:GetDescendants() : Récupère tous les objets (y compris les sous-objets) dans le dossier ZonesBoost.
ipairs : Parcourt la liste des objets un par un.
for _, part in ... :
- _ est une variable non utilisée (on s’intéresse seulement à part).
- part représente chaque objet dans le dossier.

Filtrer les objets valides

if not (part:IsA("BasePart") and part.Name=="MoreJump") then continue end

part:IsA("BasePart") : Vérifie si l’objet est une Part (un bloc 3D dans Roblox).
part.Name=="MoreJump" : Vérifie si la Part s’appelle MoreJump.
continue : Si la condition n’est pas remplie, on passe à l’objet suivant (on ignore les autres objets).

Détecter la collision avec `Touched`

part.Touched:Connect(function(plr)

Touched : Événement déclenché quand un objet entre en collision avec la Part.
plr : Représente l’objet qui a touché la Part (ici, ce sera le personnage du joueur).

Récupérer le joueur et son Humanoid

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

plr.Parent : Le parent de plr est le modèle du personnage (le joueur).
character:FindFirstChild("Humanoid") : Cherche l’Humanoid dans le personnage.
- L’Humanoid est un composant Roblox qui gère les propriétés du personnage (comme la hauteur de saut).
if not humanoid then return end : Si le personnage n’a pas d’Humanoid, on arrête la fonction (cas rare, mais possible).

Gérer le COOLDOWN

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

activeCooldowns[character] : Vérifie si le personnage est déjà en cooldown.
- Si oui (true), on arrête la fonction avec return.
- Si non, on active le cooldown pour ce personnage : activeCooldowns[character] = true.

Sauvegarder et restaurer la hauteur de saut

local jumpValue = humanoid:FindFirstChild("Jump")

if jumpValue then
    humanoid.JumpHeight = jumpValue.Value
    existingFolder:Destroy()
else
    jumpValue = Instance.new("IntValue")
    jumpValue.Name = "Jump"
    jumpValue.Parent = humanoid
    jumpValue.Value = humanoid.JumpHeight
    humanoid.JumpHeight = JUMPMAX
end

jumpValue : Cherche si l’Humanoid a déjà un enfant nommé Jump (un IntValue qui stocke la hauteur de saut d’origine).
- Si Jump existe :
  - On restaure la hauteur de saut d’origine (jumpVallue.Value).
  - On supprime le IntValue car il n’est plus utile.
- Si Jump n’existe pas :
  - On crée un IntValue nommé Jump.
  - On y stocke la hauteur de saut actuelle (humanoid.JumpHeight).
  - On applique la nouvelle hauteur de saut (JUMPMAX = 80).

Attendre la fin du COOLDOWN

task.delay(COOLDOWN_DURATION)
activeCooldowns[character] = nil

task.delay(COOLDOWN_DURATION) : Attend 1 seconde (la valeur de COOLDOWN).
activeCooldowns[character] = nil : Supprime le cooldown pour ce personnage, qui peut maintenant réutiliser le boost.

Pourquoi le COOLDOWN ?

Eviter les nombreux événements de collision : Sans cooldown, le joueur spamme le boost en touchant rapidement la zone plusieurs fois.
Éviter les bugs : Sans cooldown, le script pourrait s’exécuter trop souvent et causer des problèmes.

Résumé des concepts clés

Concept	Explication
`Workspace`	L’espace 3D où se trouvent tous les objets du jeu.
`BasePart`	Une pièce de base dans Roblox (ex. : un cube, une sphère).
`Touched`	Événement déclenché quand un objet entre en collision avec un autre.
`Humanoid`	Composant qui contrôle les propriétés d’un personnage (vie, saut, etc.).
`IntValue`	Un objet Roblox qui stocke un nombre entier (ici, la hauteur de saut d’origine).
activeC`ooldowns`	Table qui suit quels joueurs sont en cooldown.
`task.delay()`	Fonction qui pause le script pendant un certain temps.

Exemple d’un script pour gérer plusieurs Boosts

-- ==================== SERVICES ====================
local Players = game:GetService("Players")

-- ==================== CONFIGURATION ====================
local ZONES_FOLDER = workspace:WaitForChild("ZonesBoost")
local COOLDOWN_DURATION = 1 -- secondes avant de pouvoir re-déclencher une zone

-- Suivi des cooldowns actifs par personnage (évite le spam de déclenchement)
local activeCooldowns = {} -- [character] = true pendant le cooldown

-- ==================== EFFETS APPLIQUÉS AU PERSONNAGE ====================

-- Rend transparent les accessoires et MeshPart du personnage
local function setPlayerTransparency(character, transparency)
	if not character then return end

	for _, child in ipairs(character:GetChildren()) do
		if child:IsA("Accessory") then
			-- Rend transparent les BasePart/Decal de l'accessoire
			for _, descendant in ipairs(child:GetDescendants()) do
				if descendant:IsA("BasePart") or descendant:IsA("Decal") then
					descendant.Transparency = transparency
				end
			end
		elseif child:IsA("MeshPart") then
			-- Le MeshPart lui-même est la part à rendre transparente
			child.Transparency = transparency
		end
	end
end

-- Modifie la taille (échelle) du personnage
local function setPlayerScale(character, scale)
	if not character then return end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid then return end
	print("scale: ", scale)
	humanoid.BodyHeightScale.Value = scale
	humanoid.BodyWidthScale.Value = scale
	humanoid.BodyDepthScale.Value = scale
	humanoid.HeadScale.Value = scale
end

-- Modifie la vitesse de marche du personnage
local function setPlayerSpeed(character, speed)
	if not character then return end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid then return end

	humanoid.WalkSpeed = speed
end

-- Modifie la hauteur de saut du personnage
local function setPlayerJump(character, jumpHeight)
	if not character then return end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid then return end

	humanoid.JumpHeight = jumpHeight
end

-- ==================== VALEURS PAR DÉFAUT (pour restaurer l'état d'origine) ====================

local function getDefaultTransparency(character)
	if not character then return nil end
	return 0
end

local function getDefaultScale(character)
	if not character then return nil end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid then return nil end
	return humanoid.BodyHeightScale.Value
end

local function getDefaultSpeed(character)
	if not character then return nil end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid then return nil end
	return humanoid.WalkSpeed
end

local function getDefaultJump(character)
	if not character then return nil end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid then return nil end
	return humanoid.JumpHeight
end

-- ==================== CONFIGURATION DES BOOSTS ====================
-- Chaque boost définit : sa valeur max, comment récupérer la valeur par défaut,
-- le nom de la valeur stockée sur le personnage, et l'action à appliquer
local BOOSTS = {
	MoreSpeed = {
		max = 50,
		default = getDefaultSpeed,
		valueName = "Speed",
		action = setPlayerSpeed,
	},
	MoreJump = {
		max = 80,
		default = getDefaultJump,
		valueName = "Jump",
		action = setPlayerJump,
	},
	LessScale = {
		max = 0.3,
		default = getDefaultScale,
		valueName = "Scale",
		action = setPlayerScale,
	},
	Invisibility = {
		max = 0.9,
		default = getDefaultTransparency,
		valueName = "Transparency",
		action = setPlayerTransparency,
	},
}

-- ==================== LOGIQUE DE ZONE ====================
-- Applique ou retire un boost selon l'état actuel du personnage (toggle)
local function handleBoostTouch(character, boost)
	local existingValue = character:FindFirstChild(boost.valueName)

	if existingValue then
		-- Le boost est déjà actif : on restaure la valeur d'origine et on nettoie
		boost.action(character, existingValue.Value)
		existingValue:Destroy()
	else
		-- Le boost n'est pas actif : on sauvegarde la valeur par défaut, puis on applique le boost max
		local defaultValue = boost.default(character)
		if not defaultValue then return end -- sécurité : impossible de sauvegarder, on annule

		local savedValue = Instance.new("IntValue")
		savedValue.Name = boost.valueName
		savedValue.Value = defaultValue
		savedValue.Parent = character

		boost.action(character, boost.max)
	end
end

for _, part in ipairs(ZONES_FOLDER:GetDescendants()) do
	if not part:IsA("BasePart") then continue end

	local boost = BOOSTS[part.Name]
	if not boost then continue end
	
	print(boost)

	part.Touched:Connect(function(hit)
		local character = hit.Parent
		if not character then return end

		local humanoid = character:FindFirstChildOfClass("Humanoid")
		if not humanoid then return end

		-- Vérifie que c'est bien un personnage joueur (pas un NPC ou une part aléatoire)
		local player = Players:GetPlayerFromCharacter(character)
		if not player then return end

		-- Vérifie le cooldown pour éviter le spam de déclenchement
		if activeCooldowns[character] then return end
		activeCooldowns[character] = true

		handleBoostTouch(character, boost)

		-- Réinitialise le cooldown après le délai
		task.delay(COOLDOWN_DURATION, function()
			activeCooldowns[character] = nil
		end)
	end)
end

-- ==================== NETTOYAGE ====================
Players.PlayerRemoving:Connect(function(player)
	-- Nettoyage complet pour éviter les fuites mémoire quand un joueur quitte le jeu
	local character = player.Character
	if not character then return end

	activeCooldowns[character] = nil
	
	-- Supprimer tous les IntValue liés aux boosts
	for _, boost in pairs(BOOSTS) do
		local value = character:FindFirstChild(boost.valueName)
		if value then
			value:Destroy()
		end
	end
end)

Ce script permet de créer 4 types de zones de boost dans un seul script :

MoreSpeed : Augmente la vitesse de marche (WalkSpeed).
MoreJump : Augmente la hauteur de saut (JumpHeight).
MoreScale : Réduit la taille du personnage (échelle).
Transparency : Rend le personnage transparent.

Chaque zone est une BasePart dans le dossier ZonesBoost. Quand un joueur touche une zone, le boost correspondant est activé ou désactivé (toggle). Un cooldown empêche le spam.

Structure de la table `BOOSTS`

La table BOOSTS est le cœur du script. Elle définit les propriétés et comportements de chaque boost sous forme de sous-tables.

Définition de `BOOSTS`

local BOOSTS = {
    MoreSpeed = {
        max = 50,                          -- Valeur maximale du boost (ex: WalkSpeed = 50)
        default = getDefaultSpeed,        -- Fonction pour récupérer la valeur par défaut
        valueName = "Speed",               -- Nom de la valeur stockée sur le personnage (ex: IntValue "Speed")
        action = setPlayerSpeed,           -- Fonction à appeler pour appliquer le boost
    },
    MoreJump = {
        max = 80,
        default = getDefaultJump,
        valueName = "Jump",
        action = setPlayerJump,
    },
    MoreScale = {
        max = 1.5,
        default = getDefaultScale,
        valueName = "Scale",
        action = setPlayerScale,
    },
    Transparency = {
        max = 0.9,
        default = getDefaultTransparency,
        valueName = "Transparency",
        action = setPlayerTransparency,
    },
}

Explication des champs

Champ	Type	Rôle	Exemple pour MoreSpeed
`max`	`number`	Valeur maximale du boost (ex: `WalkSpeed = 50`).	`50`
`default`	`function`	Fonction qui récupère la valeur par défaut du personnage (ex: `WalkSpeed` initiale).	`getDefaultSpeed` (retourne `humanoid.WalkSpeed`)
`valueName`	`string`	Nom de l’`IntValue` stocké sur le personnage pour sauvegarder la valeur d’origine.	`"Speed"`
`action`	`function`	Fonction qui applique le boost (ex: modifie `WalkSpeed`).	`setPlayerSpeed(character, 50)`

Pourquoi cette structure ?

Modularité : Chaque boost est indépendant et peut être modifié sans toucher aux autres.
Réutilisabilité : Les fonctions (default, action) sont partagées entre tous les boosts du même type.
Extensibilité : Pour ajouter un nouveau boost, il suffit d’ajouter une entrée dans BOOSTS.

3. Fonctionnement des boosts (Toggle)

Le script utilise un mécanisme de toggle :

1ère collision : Active le boost (ex: WalkSpeed = 50).
2ème collision : Désactive le boost et restaure la valeur d’origine.

Fonction `handleBoostTouch`

local function handleBoostTouch(character, boost)
    local existingValue = character:FindFirstChild(boost.valueName)

    if existingValue then
        -- Boost déjà actif : on restaure la valeur d'origine
        boost.action(character, existingValue.Value)
        existingValue:Destroy()
    else
        -- Boost inactif : on sauvegarde la valeur par défaut, puis on applique le boost
        local defaultValue = boost.default(character)
        if not defaultValue then return end

        local savedValue = Instance.new("IntValue")
        savedValue.Name = boost.valueName
        savedValue.Value = defaultValue
        savedValue.Parent = character

        boost.action(character, boost.max)
    end
end

Explication du toggle

Vérification de existingValue :
- Le script cherche un IntValue dans le character avec le nom boost.valueName (ex: "Speed").
- Si existingValue existe → Le boost est déjà actif :
  - On restaure la valeur d’origine (existingValue.Value) en appelant boost.action.
  - On supprime l’IntValue pour indiquer que le boost est désactivé.
- Si existingValue n’existe pas → Le boost est inactif :
  - On récupère la valeur par défaut avec boost.default(character) (ex: getDefaultSpeed).
  - On crée un IntValue pour stocker cette valeur dans le character.
  - On applique le boost avec boost.action(character, boost.max).

Exemple concret avec `MoreSpeed`

1ère collision:
- existingValue = nil → Boost inactif.
- defaultValue = getDefaultSpeed(character) → Récupère WalkSpeed initiale (ex: 16).
- Crée un IntValue nommé "Speed" avec Value = 16.
- Applique setPlayerSpeed(character, 50) → WalkSpeed = 50.
2ème collision:
- existingValue = IntValue "Speed" (Value = 16) → Boost actif.
- Applique setPlayerSpeed(character, 16) → Restaure WalkSpeed = 16.
- Supprime l’IntValue "Speed".

Nettoyage mémoire (Éviter les fuites)

Pourquoi nettoyer ?

Fuites mémoire : Si un joueur quitte le jeu, ses IntValue (ex: "Speed", "Jump") restent dans le character.
Cooldowns actifs : La table activeCooldowns conserve des références aux character qui n’existent plus.
Performances : Accumuler des objets inutiles ralentit le jeu.

Nettoyage dans `PlayerRemoving`

Players.PlayerRemoving:Connect(function(player)
    local character = player.Character
    if not character then return end

    activeCooldowns[character] = nil  -- Supprime le cooldown du joueur
end)

Explications

PlayerRemoving : Événement déclenché quand un joueur quitte le jeu.
activeCooldowns[character] = nil :
- Supprime l’entrée du character dans activeCooldowns pour éviter de garder des références inutiles.

5. Fonctions de boost et valeurs par défaut

Fonctions d’action (`setPlayer...`)

Ces fonctions appliquent un effet au personnage :

setPlayerSpeed(character, speed) : Modifie humanoid.WalkSpeed.
setPlayerJump(character, jumpHeight) : Modifie humanoid.JumpHeight.
setPlayerScale(character, scale) : Modifie l’échelle du personnage (BodyHeightScale, etc.).
setPlayerTransparency(character, transparency) : Rend les accessoires et MeshPart transparents.

Fonctions de valeur par défaut (`getDefault...`)

Ces fonctions récupèrent la valeur d’origine du personnage :

getDefaultSpeed(character) : Retourne humanoid.WalkSpeed.
getDefaultJump(character) : Retourne humanoid.JumpHeight.
getDefaultScale(character) : Retourne humanoid.BodyHeightScale.Value.
getDefaultTransparency(character) : Retourne 0 (par défaut, les objets ne sont pas transparents).

6. Logique de détection des zones

Boucle sur les zones

for _, part in ipairs(ZONES_FOLDER:GetDescendants()) do
    if not part:IsA("BasePart") then continue end

    local boost = BOOSTS[part.Name]  -- Récupère la configuration du boost
    if not boost then continue end    -- Ignore si la part n'est pas une zone de boost

    part.Touched:Connect(function(hit)
        -- Vérifications (character, humanoid, player, cooldown)
        -- ...
        handleBoostTouch(character, boost)
    end)
end

Explications

Parcours des BasePart dans ZonesBoost :
- Seules les BasePart avec un nom correspondant à une clé de BOOSTS (ex: "MoreSpeed") sont prises en compte.
Événement Touched :
- Quand un joueur touche une zone, handleBoostTouch est appelé avec le character et le boost correspondant.
Vérifications :
- hit.Parent doit être un character valide.
- Le character doit avoir un Humanoid.
- Le character doit appartenir à un Player (pas un NPC).
- Le character ne doit pas être en cooldown (activeCooldowns).

7. Gestion du cooldown

Mécanisme

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

-- Après application du boost :
task.delay(COOLDOWN_DURATION, function()
    activeCooldowns[character] = nil
end)

Explications

activeCooldowns : Table qui stocke les character en cooldown ([character] = true).
task.delay :
- Planifie la réinitialisation du cooldown après COOLDOWN_DURATION secondes.
- Évite de bloquer le thread principal (contrairement à task.wait).

Résumé des points clés

Éléments	Rôle
`BOOSTS`	Table qui définit les 4 boosts (vitesse, saut, taille, transparence).
`valueName`	Nom de l’`IntValue` stocké dans le `character` pour sauvegarder la valeur d’origine.
`default`	Fonction qui récupère la valeur d’origine (ex: `WalkSpeed` initiale).
`action`	Fonction qui applique le boost (ex: `setPlayerSpeed`).
`handleBoostTouch`	Gère le toggle (activation/désactivation) du boost.
`activeCooldowns`	Table qui empêche le spam en bloquant les déclenchements pendant `COOLDOWN_DURATION`.
`PlayerRemoving`	Nettoie les cooldowns quand un joueur quitte le jeu.
`IntValue`	Stocke la valeur d’origine du boost dans le `character` pour la restaurer plus tard.

Améliorations possibles

Gestion des erreurs :
- Ajouter des warn pour déboguer (ex: si defaultValue est nil).
Effets visuels/sonores :
- Ajouter des particules ou des sons quand un boost est activé/désactivé.
Cooldown par boost :
- Actuellement, le cooldown est global (un seul boost à la fois).
- Pour permettre plusieurs boosts simultanés, utiliser une table de cooldowns par type de boost :
- local cooldowns = {} -- [character] = { MoreSpeed = true, MoreJump = false, ... } -- Dans handleBoostTouch : if cooldowns[character] and cooldowns[character][boostName] then return end cooldowns[character][boostName] = true task.delay(COOLDOWN_DURATION, function() cooldowns[character][boostName] = nil end)

Compréhension du script des boosts

Consignes : Choisis une seule réponse par question.

Question 1 : À quoi sert la table `BOOSTS` dans le script ?

A. À stocker les joueurs qui ont activé un boost.
B. À définir les propriétés (valeur maximale, action, etc.) pour chaque type de boost (vitesse, saut, taille, transparence).
C. À enregistrer les positions des zones de boost dans le jeu.
D. À gérer les cooldowns des joueurs.

Question 2 : Que fait la fonction `handleBoostTouch` quand un joueur touche une zone de boost pour la première fois ?

A. Elle supprime le boost et restaure la valeur par défaut.
B. Elle vérifie si le joueur a déjà utilisé un boost.
C. Elle applique le boost, sauvegarde la valeur d’origine dans un IntValue, et active le cooldown.
D. Elle change la couleur de la zone de boost.

Question 3 : Pourquoi utilise-t-on `activeCooldowns` dans le script ?

A. Pour stocker les valeurs maximales des boosts.
B. Pour compter le nombre de joueurs ayant utilisé un boost.
C. Pour désactiver définitivement un boost.
D. Pour éviter qu’un joueur ne déclenche plusieurs fois le même boost trop rapidement.

Question 4 : Que se passe-t-il si un joueur touche une zone de boost alors qu’il a déjà activé ce boost ?

A. Le boost est désactivé, et la valeur d’origine est restaurée.
B. Rien, le boost reste actif indéfiniment.
C. Le boost est réappliqué avec une valeur plus forte.
D. Le joueur est téléporté à un autre endroit.

Question 5 : Pourquoi faut-il nettoyer les `IntValue` et `activeCooldowns` quand un joueur quitte le jeu ?

A. Pour accélérer le jeu.
B. Pour éviter les fuites mémoire et les références à des objets qui n’existent plus.
C. Pour réinitialiser les boosts pour tous les joueurs.
D. Pour changer l’apparence des zones de boost.

Objets à créer dans le Workspace de Roblox

Exemple de script pour sauter plus haut

Déclaration des variables globales

Récupérer les objets du Workspace

Filtrer les objets valides

Détecter la collision avec Touched

Récupérer le joueur et son Humanoid

Gérer le COOLDOWN

Sauvegarder et restaurer la hauteur de saut

Attendre la fin du COOLDOWN

Pourquoi le COOLDOWN ?

Résumé des concepts clés

Exemple d’un script pour gérer plusieurs Boosts

Structure de la table BOOSTS

Définition de BOOSTS

Explication des champs

Pourquoi cette structure ?

3. Fonctionnement des boosts (Toggle)

Fonction handleBoostTouch

Explication du toggle

Exemple concret avec MoreSpeed

Nettoyage mémoire (Éviter les fuites)

Pourquoi nettoyer ?

Nettoyage dans PlayerRemoving

Explications

5. Fonctions de boost et valeurs par défaut

Fonctions d’action (setPlayer...)

Fonctions de valeur par défaut (getDefault...)

6. Logique de détection des zones

Boucle sur les zones

Explications

7. Gestion du cooldown

Mécanisme

Explications

Résumé des points clés

Améliorations possibles

Compréhension du script des boosts

Question 1 : À quoi sert la table BOOSTS dans le script ?

Question 2 : Que fait la fonction handleBoostTouch quand un joueur touche une zone de boost pour la première fois ?

Question 3 : Pourquoi utilise-t-on activeCooldowns dans le script ?

Question 4 : Que se passe-t-il si un joueur touche une zone de boost alors qu’il a déjà activé ce boost ?

Question 5 : Pourquoi faut-il nettoyer les IntValue et activeCooldowns quand un joueur quitte le jeu ?

Détecter la collision avec `Touched`

Structure de la table `BOOSTS`

Définition de `BOOSTS`

Fonction `handleBoostTouch`

Exemple concret avec `MoreSpeed`

Nettoyage dans `PlayerRemoving`

Fonctions d’action (`setPlayer...`)

Fonctions de valeur par défaut (`getDefault...`)

Question 1 : À quoi sert la table `BOOSTS` dans le script ?

Question 2 : Que fait la fonction `handleBoostTouch` quand un joueur touche une zone de boost pour la première fois ?

Question 3 : Pourquoi utilise-t-on `activeCooldowns` dans le script ?

Question 5 : Pourquoi faut-il nettoyer les `IntValue` et `activeCooldowns` quand un joueur quitte le jeu ?