Tutoriel · Gameplay

Comment faire un kill brick (de la lave) sur Roblox Studio

Un kill brick est une part qui fait réapparaître tout joueur qui la touche : la lave d'un obby, les pics d'un piège, le vide sous un parcours de parkour. Toute l'astuce tient en trois lignes : écouter Touched, trouver le Humanoid, mettre sa Health à 0. Ce guide part de là, puis passe à un seul script qui gère tous les kill bricks de ton jeu, des briques qui font perdre un peu de vie à la fois, et de la lave qui monte.

Mis à jour le 12 novembre 20267 min de lectureÉcrit par

En bref

Mets un Script dans la part. Connecte-toi à part.Touched, cherche un Humanoid dans le parent de la part qui l'a touchée, et règle humanoid.Health = 0. Pour un jeu avec beaucoup de parts de lave, tague-les KillBrick et utilise un seul Script dans ServerScriptService qui prépare chaque part taguée.

  • Mettre Health à 0 tue même à travers un ForceField. Humanoid:TakeDamage ne fait rien tant qu'un ForceField est actif, c'est pourquoi la protection d'apparition bloque les briques à dégâts.
  • Utilise un Script (serveur), pas un LocalScript, pour que la mort compte pour tout le monde.
  • Une part qui avance vers un joueur immobile peut ne pas déclencher Touched, donc la lave qui monte vérifie plutôt les positions (étape 3).
Sur cette page
  1. Fonctionnement
  2. 1. Une part
  3. 2. Tags
  4. 3. Lave qui monte
  5. 4. Tester
  6. Problèmes courants
  7. Avec RoCode
  8. Questions fréquentes
  9. Sources et lectures

Comment marche un kill brick

Chaque part déclenche un événement Touched quand une autre part la touche, et passe cette autre part à ta fonction. Quand un joueur marche sur de la lave, la part qui la touche est un pied ou une jambe, et son parent est le Model du personnage. Le personnage a un Humanoid, qui contient la santé du joueur. Mets cette santé à 0 et Roblox fait tomber le personnage en morceaux et fait réapparaître le joueur.

Deux façons de blesser un joueur
CodeCe qu'il faitAvec un ForceField
humanoid.Health = 0Tue tout de suite.Tue quand même.
humanoid:TakeDamage(20)Enlève 20 points de vie.Ne fait rien.

Étape 1 : le kill brick le plus simple

  1. Insère une Part dans le Workspace. Mets-la en rouge ou en orange, règle Material sur Neon pour un effet de lave, et coche Anchored pour qu'elle ne tombe pas.
  2. Survole la part dans l'Explorer, clique sur + et insère un Script. Nomme-le KillScript.
  3. Remplace son contenu par le code ci-dessous et appuie sur Play. Marche sur la part.
Script dans la part nommé KillScript
-- Script dans la part qui doit tuer les joueurs, nommé KillScript.
local part = script.Parent :: BasePart

part.Touched:Connect(function(hit: BasePart)
	local character = hit.Parent
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid then
		humanoid.Health = 0
	end
end)

hit.Parent est le Model auquel appartient la part qui touche. FindFirstChildOfClass("Humanoid") renvoie nil pour tout ce qui n'est pas un personnage, comme une brique libre qui roule, donc rien ne se passe dans ce cas. Cette version tue aussi les PNJ, ce qui peut être ce que tu veux pour un piège.

Ça marche, mais 30 parts de lave voudraient dire 30 copies du script, et une correction devrait être faite 30 fois. L'étape 2 les remplace par un seul script.

Étape 2 : un seul script pour tous les kill bricks

Les tags sont des étiquettes que tu poses sur des parts. CollectionService:GetTagged("KillBrick") renvoie chaque part qui a ce tag, donc un seul script peut toutes les préparer, y compris les parts ajoutées plus tard pendant que le jeu tourne.

  1. Supprime le KillScript de l'étape 1 si tu l'as créé.
  2. Sélectionne chaque part de lave, trouve Tags en bas de la fenêtre Properties, clique sur + et tape KillBrick. Tague DamageBrick les pics ou les autres objets qui doivent seulement blesser.
  3. Survole ServerScriptService, clique sur +, insère un Script nommé KillBricks et colle le code ci-dessous.
Script dans ServerScriptService nommé KillBricks
-- Script dans ServerScriptService nommé KillBricks.
-- Tague les parts "KillBrick" pour tuer au toucher, ou "DamageBrick" pour blesser un peu à la fois.
local CollectionService = game:GetService("CollectionService")
local Players = game:GetService("Players")

local DAMAGE_PER_HIT = 20 -- points de vie qu'une DamageBrick enlève à chaque fois
local DAMAGE_COOLDOWN = 0.5 -- secondes entre deux coups des briques à dégâts pour un joueur

local lastHit: { [Player]: number } = {}

local function getHumanoid(hit: BasePart): Humanoid?
	local character = hit.Parent
	-- Seulement les personnages des joueurs, pas les PNJ ni les parts libres
	if not (character and character:IsA("Model") and Players:GetPlayerFromCharacter(character)) then
		return nil
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if humanoid and humanoid.Health > 0 then
		return humanoid
	end
	return nil
end

local function setUpKillBrick(part: Instance)
	if not part:IsA("BasePart") then
		return
	end
	part.Touched:Connect(function(hit: BasePart)
		local humanoid = getHumanoid(hit)
		if humanoid then
			-- Mettre Health à 0 ignore le ForceField, donc la protection d'apparition ne sauve personne
			humanoid.Health = 0
		end
	end)
end

local function setUpDamageBrick(part: Instance)
	if not part:IsA("BasePart") then
		return
	end
	part.Touched:Connect(function(hit: BasePart)
		local humanoid = getHumanoid(hit)
		local character = humanoid and humanoid.Parent
		local player = if character and character:IsA("Model") then Players:GetPlayerFromCharacter(character) else nil
		if not (humanoid and player) then
			return
		end
		local now = os.clock()
		if now - (lastHit[player] or 0) < DAMAGE_COOLDOWN then
			return
		end
		lastHit[player] = now
		-- TakeDamage ne fait rien tant que le personnage a un ForceField
		humanoid:TakeDamage(DAMAGE_PER_HIT)
	end)
end

for _, part in CollectionService:GetTagged("KillBrick") do
	setUpKillBrick(part)
end
CollectionService:GetInstanceAddedSignal("KillBrick"):Connect(setUpKillBrick)

for _, part in CollectionService:GetTagged("DamageBrick") do
	setUpDamageBrick(part)
end
CollectionService:GetInstanceAddedSignal("DamageBrick"):Connect(setUpDamageBrick)

Players.PlayerRemoving:Connect(function(player: Player)
	lastHit[player] = nil
end)

Le script ne réagit qu'aux personnages des joueurs : Players:GetPlayerFromCharacter renvoie nil pour un PNJ, donc un zombie peut traverser ta lave. Retire cette vérification si les pièges doivent aussi tuer les PNJ. Les briques à dégâts gardent un horaire par joueur dans lastHit, donc un joueur debout sur des pics perd 20 points de vie toutes les demi-secondes au lieu de mourir en une seule image, ce qui arrive sans temps de recharge parce que Touched se déclenche de nombreuses fois tant qu'un pied repose sur une part.

Beaucoup d'obbys mettent un kill brick sous chaque saut. Si ton parcours a des points de passage, le joueur réapparaît alors au dernier : le guide des points de passage d'obby (en anglais) le construit, et il marche avec ces tags tels quels.

Étape 3 : de la lave qui monte

Un sol de lave qui monte transforme n'importe quelle carte en course vers le sommet. La lave est une part ancrée déplacée par TweenService. Une part déplacée de cette façon peut entrer dans un joueur immobile sans déclencher Touched, donc ce script ne s'y fie pas : à chaque image, il vérifie si la part racine de chaque personnage est dans la lave.

  1. Crée une grande part plate en Neon en bas de ta carte et nomme-la Lava. Elle n'a pas besoin du tag KillBrick.
  2. Insère dedans un Script nommé RisingLava avec le code ci-dessous.
Script dans la part Lava nommé RisingLava
-- Script dans une part de lave, nommé RisingLava.
-- La lave monte, attend, redescend et recommence. Tout ce qui est sous sa surface meurt.
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local TweenService = game:GetService("TweenService")

local RISE_STUDS = 40 -- de combien la lave monte
local RISE_SECONDS = 60 -- combien de temps dure la montée
local PAUSE_SECONDS = 5 -- attente en haut et en bas

local lava = script.Parent :: BasePart
lava.Anchored = true
local bottom = lava.CFrame
local top = bottom + Vector3.new(0, RISE_STUDS, 0)

-- Une part ancrée qui bouge ne déclenche pas toujours Touched sur un joueur immobile,
-- donc on vérifie à chaque image si la racine de chaque personnage est dans la lave
RunService.Heartbeat:Connect(function()
	local half = lava.Size / 2
	for _, player in Players:GetPlayers() do
		local character = player.Character
		local humanoid = character and character:FindFirstChildOfClass("Humanoid")
		local root = humanoid and humanoid.RootPart
		if humanoid and root and humanoid.Health > 0 then
			-- La position de la racine dans l'espace de la lave : dedans quand chaque axe est dans la moitié de sa taille
			local offset = lava.CFrame:PointToObjectSpace(root.Position)
			if math.abs(offset.X) <= half.X and math.abs(offset.Z) <= half.Z and offset.Y <= half.Y then
				humanoid.Health = 0
			end
		end
	end
end)

local riseInfo = TweenInfo.new(RISE_SECONDS, Enum.EasingStyle.Linear)
local fallInfo = TweenInfo.new(RISE_SECONDS / 4, Enum.EasingStyle.Sine)

while true do
	local rise = TweenService:Create(lava, riseInfo, { CFrame = top })
	rise:Play()
	rise.Completed:Wait()
	task.wait(PAUSE_SECONDS)
	local fall = TweenService:Create(lava, fallInfo, { CFrame = bottom })
	fall:Play()
	fall.Completed:Wait()
	task.wait(PAUSE_SECONDS)
end

PointToObjectSpace transforme la position de la part racine en coordonnées propres à la lave, où la lave va de moins la moitié de sa taille à plus la moitié de sa taille sur chaque axe. Tout ce qui est sous la surface et dans les bords est dans la lave. Change RISE_STUDS et RISE_SECONDS pour régler la hauteur et la vitesse de la montée.

Étape 4 : le tester

  1. Ouvre la fenêtre Output (menu Window, puis Output) et appuie sur Play.
  2. Marche sur une part KillBrick : ton personnage tombe en morceaux et réapparaît après quelques secondes.
  3. Reste debout sur une DamageBrick : la barre de vie en haut à droite baisse de 20 toutes les demi-secondes.
  4. Si une brique à dégâts ne fait rien juste après ton apparition, c'est le ForceField de la SpawnLocation. Attends 10 secondes ou règle sa Duration sur 0.
  5. Pour la lave qui monte, baisse RISE_SECONDS à 10 pendant les tests pour ne pas attendre une minute.

Problèmes courants

Si la lave ne fait rien, regarde d'abord la fenêtre Output : une ligne rouge indique le script et la ligne.

Toucher la part ne fait rien

Vérifie que c'est un Script, pas un LocalScript, et pour l'étape 2 que le tag s'écrit exactement KillBrick (K et B majuscules). Vérifie aussi que la propriété CanTouch de la part est cochée.

La brique à dégâts ne blesse pas juste après l'apparition

La SpawnLocation t'a donné un ForceField, et TakeDamage ne fait rien à travers. Règle la Duration de la SpawnLocation sur 0, ou utilise un KillBrick, qui met Health à 0 et ignore le ForceField.

Les joueurs meurent dès qu'ils apparaissent

Un kill brick touche ou chevauche la SpawnLocation, ou la lave est montée au-dessus. Monte le point d'apparition ou descends la lave.

Le kill brick tue aussi les PNJ

Le script de l'étape 1 tue n'importe quel Humanoid. Celui de l'étape 2 vérifie d'abord GetPlayerFromCharacter, donc il ne tue que les joueurs.

Le faire avec RoCode

Si tu préfères ne pas tout configurer à la main, RoCode peut le construire dans le jeu que tu as ouvert. RoCode est un agent IA indépendant pour Roblox Studio, qui n'est pas fait par Roblox : tu décris le changement dans un chat web, et son plugin pour Studio crée les parts et les scripts dans ton Explorer, donc il n'y a pas de code à coller.

Tu écris

Transforme chaque part rouge en neon de mon obby en kill brick, ajoute des pics qui font 20 de dégâts, et crée sous la tour de la lave qui monte de 40 studs en une minute.

RoCode fait
  • Peut d'abord lire ton jeu pour trouver les parts dont tu parles, puis les tague et écrit un seul script pour toutes
  • Écrit les scripts avec Create Script et a pour consigne de vérifier la compilation de chacun avec Check Script
  • Place un point d'annulation avant et après chaque lot de changements, donc Ctrl+Z revient en arrière un lot à la fois

Après une construction, RoCode peut lancer son robot de test : il joue à ton jeu dans Studio, marche et touche des parts, et rapporte PASS ou FAIL. Il ne vérifie que ce qu'il a choisi de tester, donc joue aussi le parcours toi-même. Un obby entier, c'est quelques demandes : comment marche la construction d'un système par demande. Comment RoCode se connecte à Studio.

Questions fréquentes

Comment faire un kill brick sur Roblox ?

Mets un Script dans une part avec part.Touched:Connect(function(hit) ... end), trouve le Humanoid dans hit.Parent et mets sa Health à 0. L'étape 1 contient le script complet.

Comment faire de la lave qui tue sur Roblox ?

La lave est un kill brick avec un matériau Neon orange. Pour beaucoup de parts de lave, tague-les KillBrick et utilise le script unique de l'étape 2.

Pourquoi mon kill brick ne marche pas avec un ForceField ?

S'il utilise TakeDamage, un ForceField le bloque. Mettre Health = 0 tue à travers un ForceField.

Comment faire une part qui ne blesse qu'un peu ?

Utilise Humanoid:TakeDamage avec un temps de recharge par joueur, comme le fait la partie DamageBrick de l'étape 2.

Sources et lectures

Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 12 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.