Catégories
Jeu vidéo ROBLOX

Faire rouler en boucle une boule sur une pente

Dans ce tutoriel, tu vas réaliser une animation où une boule descend une pente, disparaît lorsqu’elle arrive en bas, puis réapparaît automatiquement en haut pour recommencer son parcours.

Cette technique est très utilisée dans les jeux pour créer des décors animés ou des parcours d’obstacles.

Tu vas apprendre à :

  • construire une boule avec un Part sphérique ;
  • créer une pente avec un Part Coin ;
  • détecter l’arrivée de la boule grâce à une boîte de collision ;
  • utiliser un script serveur pour replacer la boule ;
  • organiser correctement les objets dans l’Explorateur ;
  • utiliser ReplicatedStorage pour conserver un modèle de référence.
Faire rouler une boule sur une pente
Faire disparaître et réapparaître la boule
CREER un flash lumineux
creer une onde de choc
creer des etincelles
creer une projection de debris
RAJOUT D’UN SON D’EXPLOSION

Faire rouler une boule sur une pente

Crée la structure suivante sous workspace :

Pourquoi utiliser un Folder ?

Un Folder permet de ranger les objets qui appartiennent au même système.

Ici, le dossier Boules contient :

  • la pente (inclinedPlane) ;
  • la boule (Ball) ;
  • la zone de détection (HitBox).

Les avantages sont nombreux :

  • retrouver rapidement les objets ;
  • éviter d’encombrer le Workspace ;
  • simplifier les scripts ;
  • rendre le projet plus facile à modifier.

Dans un gros jeu, il peut y avoir plusieurs centaines d’objets. Une bonne organisation devient alors indispensable.

Construire la pente

Crée une Part rectangulaire.

Ensuite :

  1. agrandis-la ;
  2. ancre-la (Anchored = true).

La pente servira de support à la boule.

Construire la boule

Ajoute une Part.

La gravité pourra ainsi faire rouler la boule naturellement.

Place-la en haut de la pente.

Comment la boule est-elle positionnée dans l’espace ?

Chaque objet Roblox possède une propriété :

Position

Cette position contient trois coordonnées :

X = gauche / droite
Y = hauteur
Z = avant / arrière

Exemple :

Vector3.new(34, 15, -77)

Cela signifie :

  • 34 studs vers la droite ;
  • 15 studs de hauteur ;
  • 77 studs vers l’arrière.

Lorsque tu places la boule en haut de la pente dans Roblox Studio, Roblox lui attribue automatiquement une position.

Créer la zone de disparition

Ajoute une Part en bas de la pente.

Renomme-la :

ZoneArrivee

Paramètres :

Transparency = 1
CanCollide = false
Anchored = true

Cette Part est invisible.

Elle servira uniquement à détecter l’arrivée de la boule.

On l’appelle souvent une HitBox ou boîte de collision.

Pourquoi utiliser une boîte de collision ?

Au lieu de vérifier en permanence la position de la boule, Roblox peut détecter automatiquement lorsqu’un objet touche une zone.

Les avantages :

  • moins de calculs ;
  • code plus simple ;
  • meilleure précision.

Faire disparaître et réapparaître la boule

Où placer le script ?

Deux solutions sont possibles.

Solution 1 : ServerScriptService

ServerScriptService
 └─ GestionBoule

C’est la méthode recommandée.

Les avantages :

  • tous les scripts sont regroupés ;
  • plus facile à maintenir ;
  • meilleure sécurité.

Solution 2 : Sous le Folder

Workspace
 └─ Boules
     └─ Script

Cela fonctionne également.

Cette solution est parfois utilisée lorsque le script ne gère qu’un seul système.

Pour un petit projet comme celui-ci, cela reste acceptable, crée un script sous folder :

Saisie le code suivant :

-- récupération des ressources graphiques
local folder = script.Parent
local hitBox = folder.HitBox
local ball = folder.Ball

-- récupération du folder replicatedStorage
local replicatedStorage = game:GetService("ReplicatedStorage")

-- récupération de la position initiale de la balle
local positionInitial = ball.Position

-- modification des propriété de la ball
ball.Anchored = false
ball.CanCollide = true
ball.Name = "Ball"
-- clonage de la balle
local newBall = ball:Clone()
newBall.Parent = folder
-- rangement de la balle en modèle replicatedStorage
ball.Parent = replicatedStorage

-- détection de la collision de la balle
hitBox.Touched:Connect(function(hit)
	if hit.Name ~= "Ball" then return end

	newBall:Destroy()	
	task.wait(1)
	
	newBall = ball:Clone()	
	newBall.Parent = folder
	newBall.Anchored = false

end)

Pourquoi utiliser un Script serveur ?

Nous allons utiliser un Script et non un LocalScript.

Le serveur est responsable :

  • des objets du Workspace ;
  • de la physique ;
  • des collisions ;
  • des déplacements des Parts.

Comme la boule existe pour tous les joueurs, c’est le serveur qui doit la gérer.

Mémoriser la position de départ

Le script va enregistrer la position initiale de la boule :

local positionInitial = ball.Position

Cette variable contient les coordonnées exactes du point de départ.

Plus tard, le script pourra replacer la boule exactement au même endroit.

Sauvegarder un modèle dans ReplicatedStorage

Crée une copie parfaite de la boule.

Place cette copie dans :

-- récupération du folder replicatedStorage
local replicatedStorage = game:GetService("ReplicatedStorage")
ball.Parent = replicatedStorage

Cette boule ne sera jamais utilisée directement dans le jeu.

Elle sert de modèle de référence.

Pourquoi utiliser ReplicatedStorage ?

ReplicatedStorage permet de stocker des objets qui pourront être utilisés plus tard.

Les avantages :

  • conserver un modèle intact ;
  • recréer facilement un objet détruit ;
  • éviter de reconstruire l’objet à la main ;
  • faciliter les systèmes complexes.

Pourquoi cloner la boule ?

Lorsque la boule disparaît, il est parfois plus simple de :

  1. détruire l’ancienne ;
  2. recréer une nouvelle boule.

Pour cela :

local newBall = ball:Clone()

Le clonage produit une copie identique :

  • même taille ;
  • même couleur ;
  • mêmes propriétés ;
  • mêmes scripts éventuels.

Cette méthode est très utilisée dans les jeux Roblox.

Créer un flash lumineux

Ce script sert à créer un effet de flash lumineux à un endroit précis dans le jeu. Par exemple, il peut être utilisé lorsqu’un joueur clique, lorsqu’une explosion se produit ou lorsqu’un objet apparaît ou disparaît.

Le flash est créé sous la forme d’une petite sphère lumineuse qui grandit rapidement avant de disparaître.

Quand la fonction est appelée :

  1. une petite boule lumineuse est créée ;
  2. elle apparaît à la position demandée ;
  3. elle grossit rapidement ;
  4. elle devient transparente ;
  5. elle disparaît ;
  6. Roblox la supprime automatiquement.

Le résultat ressemble à une petite explosion lumineuse ou à un effet magique très utilisé dans les jeux Roblox.

Rajoute ce code dans ton script :

local Debris = game:GetService("Debris")
local TweenService = game:GetService("TweenService")

-- 
-- CONFIGURATION
-- 
local CONFIG = {
	-- Flash
	flashActif      = true,
	sizeFlash       = Vector3.new(20, 20, 20),
	colorFlash      = Color3.fromRGB(255, 0, 0),
}

-- 
-- EFFETS  Flash
-- 

local function creerFlash(position)
	local flash = Instance.new("Part")
	flash.Shape = Enum.PartType.Ball
	flash.Size = Vector3.new(0.1, 0.1, 0.1)
	flash.Position = position
	flash.Anchored = true
	flash.CanCollide = false
	flash.CastShadow = false
	flash.Material = Enum.Material.Neon
	flash.Color = CONFIG.colorFlash
	flash.Parent = workspace

	local tween = TweenService:Create(flash,
		TweenInfo.new(0.15, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
		{ Size = CONFIG.sizeFlash, Transparency = 1 }
	)
	tween:Play()
	Debris:AddItem(flash, 0.2)
end

-- 
-- EXPLOSION PRINCIPALE
-- 
local function exploser(ball)
	local position = ball.Position

	ball.CanCollide = false
	ball.Transparency = 1

	if CONFIG.flashActif   then creerFlash(position)      end

	ball:Destroy()
end

Puis modifie ton script pour appeler le flash lorsque la balle touche la HitBox :


-- détection de la collision de la balle
hitBox.Touched:Connect(function(hit)
	if hit.Name ~= "Ball" then return end
	exploser(newBall)
		
	task.wait(1)
	
	newBall = ball:Clone()	
	newBall.Parent = folder
	newBall.Anchored = false

end)

Crée une onde de choc

Ce script crée une onde de choc visuelle qui se propage autour d’un point précis.

Tu peux imaginer ce qui se passe lorsqu’une pierre tombe dans l’eau : une vague se forme puis s’agrandit progressivement. Ici, c’est le même principe, mais sous la forme d’une sphère lumineuse qui grandit avant de disparaître.

Ce type d’effet est souvent utilisé pour :

  • une explosion ;
  • un sort magique ;
  • un impact puissant ;
  • l’arrivée d’un boss ;
  • une compétence spéciale.
-- Script dans la boule (Part) ou un Script serveur

local Debris = game:GetService("Debris")
local TweenService = game:GetService("TweenService")

-- 
-- CONFIGURATION
-- 
local CONFIG = {
	-- Onde de choc
	ondeActive      = true,
	ondeCouleur     = Color3.fromRGB(255, 150, 0),
	-- Dégâts (rayon)
	rayonDegats     = 40,
	forceDegats     = 80,
	-- Flash
	flashActif      = true,
	sizeFlash       = Vector3.new(20, 20, 20),
	colorFlash      = Color3.fromRGB(255, 0, 0),

}

-- 
-- EFFETS ONDE DE CHOC
-- 

local function creerOndeChoc(position)
	local onde = Instance.new("Part")
	onde.Shape = Enum.PartType.Ball
	onde.Size = Vector3.new(1, 1, 1)
	onde.Position = position
	onde.Anchored = true
	onde.CanCollide = false
	onde.CastShadow = false
	onde.Material = Enum.Material.Neon
	onde.Color = CONFIG.ondeCouleur
	onde.Transparency = 0.3
	onde.Parent = workspace

	local tween = TweenService:Create(onde,
		TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
		{ Size = Vector3.new(CONFIG.rayonDegats * 2, CONFIG.rayonDegats * 2, CONFIG.rayonDegats * 2), Transparency = 1 }
	)
	tween:Play()
	Debris:AddItem(onde, 0.5)
end

local function appliquerForce(position)
	for _, part in ipairs(workspace:GetPartBoundsInRadius(position, CONFIG.rayonDegats)) do
		if part.Anchored then continue end
		local direction = (part.Position - position)
		local distance = direction.Magnitude
		if distance < 0.1 then continue end
		local force = (1 - distance / CONFIG.rayonDegats) * CONFIG.forceDegats
		part:ApplyImpulse(direction.Unit * force * part.AssemblyMass)
	end
end


-- 
-- EXPLOSION PRINCIPALE
-- 
local function exploser(ball)
	local position = ball.Position

	ball.CanCollide = false
	ball.Transparency = 1

	if CONFIG.flashActif   then creerFlash(position)      end
	if CONFIG.ondeActive   then creerOndeChoc(position)   end

	appliquerForce(position)
	ball:Destroy()

end

Lorsque la fonction creerOndeChoc() est appelée :

  1. une petite sphère lumineuse apparaît ;
  2. elle est placée au centre de l’explosion ;
  3. elle s’agrandit jusqu’au rayon défini dans la configuration ;
  4. elle devient progressivement transparente ;
  5. elle disparaît ;
  6. Roblox la supprime automatiquement.

Cette technique permet de créer facilement des effets spectaculaires pour des explosions, des sorts magiques ou des impacts puissants dans un jeu Roblox.

Créer de la fumée

Ce script permet de créer un effet de fumée à un endroit précis dans le jeu.

Cet effet peut être utilisé pour représenter :

  • une explosion ;
  • un moteur ;
  • un incendie ;
  • une cheminée ;
  • l’impact d’un projectile.

La fumée apparaît pendant un court instant, puis disparaît automatiquement.

-- ═══════════════════════════════════════
-- CONFIGURATION
-- ═══════════════════════════════════════
local CONFIG = {
	-- Fumée
	fumeeActive     = true,
	-- Onde de choc
	ondeActive      = true,
	ondeCouleur     = Color3.fromRGB(255, 150, 0),
	-- Dégâts (rayon)
	rayonDegats     = 40,
	forceDegats     = 80,
	-- Flash
	flashActif      = true,
	sizeFlash       = Vector3.new(20, 20, 20),
	colorFlash      = Color3.fromRGB(255, 0, 0),

}

-- ═══════════════════════════════════════
-- EFFETS FUMEE
-- ═══════════════════════════════════════

l
local function creerFumee(position)
	local anchor = Instance.new("Part")
	anchor.Size = Vector3.new(1, 1, 1)
	anchor.Position = position
	anchor.Anchored = true
	anchor.CanCollide = false
	anchor.Transparency = 1
	anchor.Parent = workspace

	local fumee = Instance.new("Smoke")
	fumee.Color = Color3.fromRGB(80, 80, 80)
	fumee.Opacity = 0.5
	fumee.RiseVelocity = 10
	fumee.Size = 12
	fumee.Parent = anchor

	-- Couper la fumée puis supprimer
	task.delay(0.3, function()
		fumee.Enabled = false
	end)
	Debris:AddItem(anchor, 3)
end

-- ═══════════════════════════════════════
-- EXPLOSION PRINCIPALE
-- ═══════════════════════════════════════
local function exploser(ball)
	local position = ball.Position

	ball.CanCollide = false
	ball.Transparency = 1

	if CONFIG.flashActif   then creerFlash(position)      end
	if CONFIG.ondeActive   then creerOndeChoc(position)   end
	if CONFIG.fumeeActive  then creerFumee(position)      end

	appliquerForce(position)
	ball:Destroy()

end

L’objet Smoke ne peut pas exister seul.

Il doit être attaché à un objet Roblox.

La Part invisible sert donc de :

  • support ;
  • point d’émission ;
  • repère dans l’espace.

Le joueur ne la voit jamais, mais elle permet à la fumée de fonctionner correctement.

Lorsque la fonction creerFumee() est appelée :

  • un support invisible est créé ;
  • un effet Smoke est ajouté dessus ;
  • la fumée grise est émise ;
  • elle monte rapidement ;
  • l’émission s’arrête après 0,3 seconde ;
  • Roblox supprime automatiquement l’ensemble après 3 secondes.

Cette technique permet d’ajouter facilement des effets visuels réalistes à tes explosions et animations dans Roblox.

Création d’étincelles

Ce script permet de créer un effet d’étincelles semblable à celui d’une explosion, d’un feu d’artifice ou d’un impact métallique.

Lorsqu’il est exécuté, plusieurs petites sphères lumineuses sont créées au même endroit. Elles partent ensuite dans différentes directions à des vitesses variées avant de disparaître progressivement.

Création de plusieurs étincelles

La fonction utilise une boucle qui se répète autant de fois que la valeur définie dans :

CONFIG.nbEtincelles

Si cette valeur est égale à 20, alors 20 étincelles seront créées.

Plus cette valeur est grande, plus l’effet sera spectaculaire, mais aussi plus il demandera de calculs à Roblox.


-- Script dans la boule (Part) ou un Script serveur
local Debris = game:GetService("Debris")
local TweenService = game:GetService("TweenService")

-- ═══════════════════════════════════════
-- CONFIGURATION
-- ═══════════════════════════════════════
local CONFIG = {
	-- Particules
	nbEtincelles    = 50,
	-- Fumée
	fumeeActive     = true,
	-- Onde de choc
	ondeActive      = true,
	ondeCouleur     = Color3.fromRGB(255, 150, 0),
	-- Dégâts (rayon)
	rayonDegats     = 40,
	forceDegats     = 80,
	-- Flash
	flashActif      = true,
	sizeFlash       = Vector3.new(20, 20, 20),
	colorFlash      = Color3.fromRGB(255, 0, 0),

}

-- ═══════════════════════════════════════
-- EFFETS ETINCELLES
-- ═══════════════════════════════════════

local function creerEtincelles(position)
	for i = 1, CONFIG.nbEtincelles do
		local etincelle = Instance.new("Part")
		etincelle.Shape = Enum.PartType.Ball
		-- taille des etincelles 
		etincelle.Size = Vector3.new(0.2, 0.2, 0.2)
		etincelle.Position = position
		etincelle.CanCollide = false
		etincelle.CastShadow = false
		etincelle.Material = Enum.Material.Neon
		-- Couleur aléatoire entre orange et jaune
		etincelle.Color = Color3.fromRGB(255, math.random(100, 255), 0)
		etincelle.Parent = workspace

		-- Direction aléatoire
		local direction = Vector3.new(
			math.random(-100, 100) / 100,
			math.random(20, 100) / 100,
			math.random(-100, 100) / 100
		).Unit
		-- vitesse aléatoire de propagation des étincelles
		local vitesse = math.random(20, 200)
		local vb = Instance.new("BodyVelocity")
		vb.Velocity = direction * vitesse
                -- Autorise une poussée très forte sur les axes X, Y et Z pour propulser l'étincelle 1e4 = 10000
		vb.MaxForce = Vector3.new(1e4, 1e4, 1e4)
		vb.Parent = etincelle

		-- Disparition progressive
		local duree = math.random(5, 12) / 10
		local tween = TweenService:Create(etincelle,
			TweenInfo.new(duree, Enum.EasingStyle.Quad, Enum.EasingDirection.In),
			{ Transparency = 1, Size = Vector3.new(0.05, 0.05, 0.05) }
		)
		tween:Play()
		Debris:AddItem(etincelle, duree)
	end
end

-- ═══════════════════════════════════════
-- EXPLOSION PRINCIPALE
-- ═══════════════════════════════════════
local function exploser(ball)
	local position = ball.Position

	ball.CanCollide = false
	ball.Transparency = 1

	if CONFIG.flashActif   then creerFlash(position)      end
	if CONFIG.ondeActive   then creerOndeChoc(position)   end


	if CONFIG.fumeeActive  then creerFumee(position)      end
	
	creerEtincelles(position)

	appliquerForce(position)
	ball:Destroy()

end

Apparence des étincelles

Chaque étincelle est représentée par une très petite sphère lumineuse.

Le matériau Neon lui donne un aspect brillant qui ressemble à une particule incandescente.

Pour rendre l’effet plus réaliste, la couleur n’est pas toujours la même. Le rouge reste au maximum tandis que le vert varie aléatoirement. Cela produit différentes nuances allant :

  • du jaune vif ;
  • à l’orange ;
  • jusqu’à l’orange foncé.

Comme dans une véritable explosion, toutes les étincelles n’ont donc pas exactement la même couleur.

Une direction différente pour chaque étincelle

Après leur création, les étincelles doivent se disperser.

Le script génère donc une direction aléatoire pour chacune d’elles.

Certaines partent :

  • vers la gauche ;
  • vers la droite ;
  • vers l’avant ;
  • vers l’arrière ;
  • vers le haut.

Cette dispersion donne l’impression d’une véritable projection de particules.

Si toutes les étincelles allaient dans la même direction, l’effet serait beaucoup moins naturel.

Une vitesse différente pour chaque étincelle

Le script choisit également une vitesse aléatoire.

Certaines étincelles sont éjectées très rapidement tandis que d’autres se déplacent plus lentement.

C’est ce mélange de vitesses qui rend l’explosion crédible.

Dans la réalité, les fragments d’une explosion ne se déplacent jamais tous à la même vitesse.

Utilisation de BodyVelocity

Pour propulser les étincelles, le script utilise un objet appelé BodyVelocity.

On peut le comparer à une petite poussée invisible qui agit sur chaque étincelle. Cette poussée envoie immédiatement la particule dans la direction choisie avec la vitesse calculée. Le résultat est un mouvement rapide qui donne l’impression que les étincelles jaillissent du centre de l’explosion.

Disparition progressive

Une étincelle ne reste pas visible indéfiniment. Le script lui attribue une durée de vie aléatoire. Certaines disparaissent rapidement alors que d’autres restent visibles un peu plus longtemps.

Pendant cette durée :

  • elles deviennent progressivement transparentes ;
  • leur taille diminue petit à petit.

L’effet obtenu ressemble à une braise qui refroidit et s’éteint.

Animation avec TweenService

La disparition est réalisée grâce à TweenService.

Au lieu de rendre l’étincelle invisible d’un seul coup, Roblox anime progressivement :

  • la transparence ;
  • la taille.

L’étincelle semble donc se consumer naturellement avant de disparaître.

Nettoyage automatique

Une fois son animation terminée, chaque étincelle est supprimée grâce au service Debris. Cela évite d’accumuler des centaines de petits objets invisibles dans le jeu. C’est une étape importante pour conserver de bonnes performances.

Ce que voit le joueur

Lorsqu’une explosion se produit :

  1. plusieurs petites boules lumineuses apparaissent ;
  2. elles partent dans toutes les directions ;
  3. certaines vont plus vite que d’autres ;
  4. elles deviennent progressivement transparentes ;
  5. elles rétrécissent ;
  6. elles disparaissent complètement.

L’ensemble crée un effet très proche des étincelles d’un feu d’artifice, d’une explosion ou d’un choc métallique.

Créer un effet de projection de débris

Ce script sert à simuler une explosion de petits morceaux de matière, comme des cailloux, des fragments de mur ou des débris projetés au sol.

L’idée est simple : au lieu d’avoir un seul effet, on génère plusieurs petits objets qui partent dans toutes les directions avec des tailles et des vitesses différentes.


-- ═══════════════════════════════════════
-- CONFIGURATION
-- ═══════════════════════════════════════
local CONFIG = {
	-- Particules
	nbEtincelles    = 50,
	nbDebris        = 10,
	-- Fumée
	fumeeActive     = true,
	-- Onde de choc
	ondeActive      = true,
	ondeCouleur     = Color3.fromRGB(255, 150, 0),
	-- Dégâts (rayon)
	rayonDegats     = 40,
	forceDegats     = 80,
	-- Flash
	flashActif      = true,
	sizeFlash       = Vector3.new(20, 20, 20),
	colorFlash      = Color3.fromRGB(255, 0, 0),

}

-- ═══════════════════════════════════════
-- EFFETS DEBRIS
-- ═══════════════════════════════════════


local function creerDebris(position)
	for i = 1, CONFIG.nbDebris do
		local morceau = Instance.new("Part")
		morceau.Shape = Enum.PartType.CornerWedge
		morceau.Size = Vector3.new(
			math.random(1, 4) / 10,
			math.random(1, 4) / 10,
			math.random(1, 4) / 10
		)
		morceau.Position = position + Vector3.new(
			math.random(-2, 2),
			math.random(0, 2),
			math.random(-2, 2)
		)
		morceau.Material = Enum.Material.SmoothPlastic
		morceau.Color = Color3.fromRGB(80, 80, 80)
		morceau.Parent = workspace

		local direction = Vector3.new(
			math.random(-100, 100) / 100,
			math.random(30, 100) / 100,
			math.random(-100, 100) / 100
		).Unit

		local vb = Instance.new("BodyVelocity")
		vb.Velocity = direction * math.random(10, 30)
		vb.MaxForce = Vector3.new(1e4, 1e4, 1e4)
		vb.Parent = morceau

		Debris:AddItem(morceau, math.random(2, 4))
	end
end

-- ═══════════════════════════════════════
-- EXPLOSION PRINCIPALE
-- ═══════════════════════════════════════
local function exploser(ball)
	local position = ball.Position

	ball.CanCollide = false
	ball.Transparency = 1

	if CONFIG.flashActif   then creerFlash(position)      end
	if CONFIG.ondeActive   then creerOndeChoc(position)   end


	if CONFIG.fumeeActive  then creerFumee(position)      end
	
	creerEtincelles(position)
	creerDebris(position)

	appliquerForce(position)
	ball:Destroy()

end

Création de plusieurs morceaux

La fonction utilise une boucle qui se répète un nombre de fois défini par :

CONFIG.nbDebris

Plus cette valeur est grande, plus l’explosion est impressionnante. Chaque boucle crée donc un nouveau morceau de débris.

Apparence des débris

Chaque fragment est une petite Part avec :

  • une taille différente à chaque fois (petits ou un peu plus gros morceaux) ;
  • une couleur gris foncé pour simuler de la pierre ou du béton ;
  • un matériau simple pour rester léger et réaliste.

L’objectif est d’éviter un rendu trop uniforme : dans une vraie explosion, tous les morceaux ne sont jamais identiques.

Position initiale aléatoire

Les débris ne sont pas tous créés exactement au même point.

Ils apparaissent légèrement autour de la position d’origine, avec un petit décalage :

  • certains un peu à gauche ;
  • d’autres un peu à droite ;
  • certains légèrement plus haut.

Cela donne l’impression que l’explosion a un vrai volume, et pas juste un point fixe.

Direction de projection

Chaque débris reçoit une direction aléatoire dans l’espace. Cette direction est calculée pour permettre :

  • une dispersion horizontale (gauche / droite / avant / arrière) ;
  • une poussée vers le haut pour simuler l’explosion.

Ensuite, cette direction est normalisée, ce qui signifie qu’on garde uniquement le sens, sans influencer la vitesse.

Mise en mouvement

Pour propulser les morceaux, le script utilise un BodyVelocity.

Ce système agit comme une poussée instantanée appliquée à chaque débris. La vitesse est également aléatoire :

  • certains morceaux partent doucement ;
  • d’autres sont projetés rapidement.

Cela rend l’effet beaucoup plus naturel et dynamique.

Durée de vie limitée

Chaque débris n’est pas permanent. Le service Debris s’occupe de supprimer automatiquement chaque morceau après un temps aléatoire.

Cela évite :

  • d’encombrer le jeu avec trop d’objets ;
  • de ralentir les performances ;
  • de laisser des débris inutiles dans le monde.

Résultat visuel

Quand la fonction est appelée, on observe :

  1. plusieurs petits morceaux apparaissent au point d’impact ;
  2. ils sont légèrement dispersés autour du centre ;
  3. ils sont projetés dans toutes les directions ;
  4. certains montent haut, d’autres restent proches du sol ;
  5. ils disparaissent progressivement.

L’ensemble donne un effet très proche :

  • d’une explosion de mur ;
  • d’un impact de balle lourde ;
  • ou d’un objet qui se casse violemment.

Rajouter un son d’explosion

Trouve et insère le dans l’arborescence :

Puis ajoute à ton script la gestion du son le son :

local soundExplosion = folder.Explosion

local function playSound(sound)
	if not sound then return end
	pcall(function() sound:Play() end)
end

Puis modifie la fonction Exploser de ton script pour ajouter le son de l’explosion :

-- 
-- EXPLOSION PRINCIPALE
-- 
local function exploser(ball)
	local position = ball.Position

	ball.CanCollide = false
	ball.Transparency = 1
	
	playSound(soundExplosion)

	if CONFIG.flashActif   then creerFlash(position)      end
	if CONFIG.ondeActive   then creerOndeChoc(position)   end

	if CONFIG.fumeeActive  then creerFumee(position)      end
	
	creerEtincelles(position)
	creerDebris(position)

	appliquerForce(position)
	ball:Destroy()
end