Roblox Guide 🇫🇷 Français

Créer un kill brick sur Roblox (guide débutant) : Touched, Humanoid et debounce expliqués

@Mateo · 6d ago

7 views 0 replies

TL;DR

Tu veux une brique qui tue le joueur dès qu'il la touche — comme dans les obbys ou les cartes de survie ? Ce guide t'explique tout, de zéro, en moins de 30 lignes de Luau. On va couvrir l'événement Touched, le composant Humanoid, les méthodes :TakeDamage() et .Health = 0, et surtout le debounce, ce petit mécanisme indispensable que personne n'explique aux débutants.

Pourquoi le kill brick est le meilleur premier projet ?

Le kill brick est l'une des compétences les plus fondamentales quand on commence à bidouiller Roblox Studio. Si tu as déjà joué à un obby ou un jeu de survie, tu en as forcément croisé : ces blocs rouges ou ces plaques de lave qui réinitialisent ton personnage dès que tu les touches.

Apprendre à en créer un ne se résume pas à faire "un bloc qui tue" : c'est ta porte d'entrée pour comprendre les événements et les fonctions en Luau, le langage de programmation utilisé par Roblox.

La logique utilisée ici — détecter un contact, récupérer l'Humanoid du joueur, et modifier une propriété — est exactement la même que celle utilisée pour les power-ups, les lignes d'arrivée, ou même des systèmes d'armes complexes.

Étape 1 — Mettre en place la scène dans Roblox Studio

Ouvre Roblox Studio et crée une nouvelle expérience vide.
Dans le Workspace, insère une nouvelle Part (clic droit → Insert Object → Part).
Renomme-la KillBrick pour t'y retrouver.
Colorie-la en rouge, mets-la en Anchored (sinon elle tombe dans le vide).
Clic droit sur la Part → Insert Object → Script (un Script normal, côté serveur, pas un LocalScript).

Attention : assure-toi que ton script est bien à l'intérieur de la Part. Si le script se trouve directement dans le Workspace, script.Parent pointera vers tout l'environnement du jeu — et ça ne fonctionnera pas.

Étape 2 — Le script de base (version minimaliste)

Double-clique sur le script que tu viens de créer, supprime tout, et colle ce code :

-- Script basique de kill brick
local killBrick = script.Parent

killBrick.Touched:Connect(function(hit)
    -- On cherche un Humanoid dans le parent de la partie touchée
    local humanoid = hit.Parent:FindFirstChildOfClass("Humanoid")

    if humanoid then
        -- On met la vie à 0 : mort instantanée
        humanoid.Health = 0
    end
end)

Lance le jeu avec le bouton Play et marche sur le bloc rouge. Ton personnage devrait mourir immédiatement.

Que fait chaque ligne ?

Ligne	Rôle
`script.Parent`	Référence la Part qui contient ce script
`.Touched:Connect(function(hit) ... end)`	Écoute l'événement "quelque chose touche cette Part" ; `hit` est la partie qui a touché
`hit.Parent`	Récupère le modèle parent de la partie touchée (le personnage du joueur)
`:FindFirstChildOfClass("Humanoid")`	Cherche un enfant de classe `Humanoid` dans ce modèle
`humanoid.Health = 0`	Met la vie à zéro, ce qui tue le personnage

Pourquoi hit.Parent et pas juste hit ? Quand un joueur touche un bloc, hit est une partie de son personnage (son pied, sa jambe…), pas le personnage entier. Le Humanoid se trouve dans le modèle parent, d'où le .Parent.

Étape 3 — Utiliser `:TakeDamage()` à la place de `.Health = 0`

Il existe deux façons de tuer le joueur :

Méthode 1 — Directe :

humanoid.Health = 0

Méthode 2 — Via :TakeDamage() :

humanoid:TakeDamage(humanoid.MaxHealth)

À l'intérieur de l'événement, on vérifie si le parent de hit contient un Humanoid. C'est important parce qu'on veut que le code affecte uniquement les joueurs et les NPCs.

On vérifie aussi que la vie du Humanoid est supérieure à 0 — inutile de tuer un personnage déjà mort. Si la vie est bien au-dessus de 0, on lui inflige des dégâts égaux à son MaxHealth, ce qui le tue instantanément.

La version propre avec cette double vérification :

local killBrick = script.Parent

killBrick.Touched:Connect(function(hit)
    local humanoid = hit.Parent:FindFirstChildOfClass("Humanoid")

    if humanoid ~= nil and humanoid.Health > 0 then
        humanoid:TakeDamage(humanoid.MaxHealth)
    end
end)

:TakeDamage() vs .Health = 0 : La différence principale est que :TakeDamage() respecte les ForceField (boucliers que Roblox place sur les joueurs à l'apparition). Si tu veux tuer même les joueurs protégés, utilise .Health = 0. Pour un comportement "fair play", préfère :TakeDamage().

Étape 4 — Le debounce : pourquoi c'est indispensable

C'est ici que la plupart des tutos débutants s'arrêtent — et c'est une erreur. Sans debounce, ton kill brick peut causer des bugs bizarres.

Le terme vient de l'idée de "rebond mécanique" d'un interrupteur. Dans le contexte de Roblox, ce problème survient principalement avec l'événement Touched : quand une partie en touche une autre, l'événement peut se déclencher plusieurs fois en très peu de temps.

Le debounce est une variable booléenne utilisée en scripting comme délai pour les événements. Par exemple, quand quelque chose déclenche la fonction Touched d'un BasePart, elle peut se déclencher plusieurs fois dans la même milliseconde. Pour éviter ça, on ajoute un if qui vérifie si la variable debounce est à true.

Voici le kill brick complet et professionnel avec debounce :

-- Kill Brick avec debounce — version finale
local killBrick = script.Parent
local debounce = false  -- false = prêt à tuer, true = en cooldown

killBrick.Touched:Connect(function(hit)
    -- Si debounce est actif, on ignore le contact
    if debounce then return end

    local humanoid = hit.Parent:FindFirstChildOfClass("Humanoid")

    if humanoid ~= nil and humanoid.Health > 0 then
        debounce = true          -- on bloque les déclenchements suivants
        humanoid.Health = 0      -- on tue le joueur

        task.wait(1)             -- on attend 1 seconde (cooldown)
        debounce = false         -- on réactive le kill brick
    end
end)

Les "debounce patterns" sont des techniques de code qui empêchent une fonction de s'exécuter trop de fois. Ici, la variable debounce joue le rôle de verrou : dès que le joueur est tué, le script se "verrouille" pendant 1 seconde, puis se "déverrouille" pour être prêt à tuer le prochain joueur.

Erreurs fréquentes chez les débutants

1. Le script ne fait rien

Vérifie l'Output (Menu View → Output). Si tu vois une erreur rouge :

Le Luau est sensible à la casse. Humanoid n'est pas pareil que humanoid. Touched n'est pas pareil que touched. Si tu vois du texte rouge dans la fenêtre Output, c'est souvent la cause.

2. La brique tombe dans le vide

Si ton kill brick n'est pas ancré (Anchored = true), il peut tomber dans le vide avant même que tu aies le temps de tester !

3. L'événement se déclenche des dizaines de fois

C'est le problème classique sans debounce. Par exemple, si tu veux que la brique soit touchable par tous les joueurs mais qu'une fois qu'un joueur l'a touchée, il ne puisse plus la toucher, il te faut un debounce adapté. La version ci-dessus avec task.wait(1) est le point de départ.

4. `FindFirstChild` vs `FindFirstChildOfClass`

hit.Parent:FindFirstChild("Humanoid") cherche un enfant dont le nom est "Humanoid".
hit.Parent:FindFirstChildOfClass("Humanoid") cherche un enfant dont la classe est "Humanoid".

En pratique pour un kill brick, les deux marchent, mais :FindFirstChildOfClass() est plus robuste car elle ne se basera pas sur un enfant mal nommé. C'est la méthode recommandée dans les scripts modernes.

Bonus — Rendre le kill brick visuel

Pour que les joueurs comprennent intuitivement que c'est dangereux, personnalise l'apparence dans le panneau Properties :

Color → rouge vif (255, 0, 0)
Material → Neon (pour qu'il brille)
Transparency → 0.3 (légèrement transparent pour l'effet "lave")
CanCollide → true (pour qu'il soit physiquement solide)

Tu n'as pas besoin de modifier le script pour ça, tout se fait dans Studio.

FAQ

Q : Est-ce que ça marche sur les NPCs aussi ?

Oui ! Tant que le NPC possède un Humanoid dans son modèle (ce qui est le cas pour tous les ennemis créés avec le Rig Builder de Roblox), le script les tuera aussi.

Q : Comment faire que ça inflige des dégâts progressifs plutôt que de tuer d'un coup ?

Remplace humanoid.Health = 0 par humanoid:TakeDamage(20) et ajuste le cooldown du debounce. Avec task.wait(0.5) et 20 dégâts par contact, le joueur mourra en ~5 touches.

Q : Puis-je mettre plusieurs kill bricks dans la même carte ?

Absolument. Chaque Part a son propre Script avec son propre debounce. Ils fonctionnent indépendamment.

Q : Faut-il un LocalScript ou un Script normal ?

Un Script normal (côté serveur). Modifier la santé d'un joueur doit toujours se faire côté serveur pour que le changement soit synchronisé pour tous les joueurs connectés.

Pour aller plus loin

Ce kill brick est ta première brique (sans jeu de mots) pour comprendre le scripting Roblox. La même logique Touched + Humanoid te servira pour créer des zones de dégâts, des power-ups de vitesse, des checkpoints d'obby, et bien plus encore.

Si tu cherches des scripts Roblox prêts à l'emploi ou des ressources de développement, tu peux aussi jeter un œil au marketplace GM Market — il y a régulièrement des assets utiles pour compléter tes projets.

Bonne chance dans tes créations — et n'hésite pas à poster tes questions dans les questions Roblox si tu bloques quelque part !

#debounce #debutant #humanoid #kill-brick #roblox #touched