===================================================================
--- original.js
+++ change.js
@@ -352,10 +352,10 @@
 		var cake = self.attachAsset('cake_' + cakeIndex, {
 			anchorX: 0.5,
 			anchorY: 0.5
 		});
-		cake.scaleX = 1.0;
-		cake.scaleY = 1.0;
+		cake.scaleX = 1.2;
+		cake.scaleY = 1.2;
 		cake.x = Math.random() * 2048;
 		cake.y = -cake.height / 2;
 		cake.speedY = 5 + Math.random() * 5;
 		cake.assetId = 'cake_' + cakeIndex; // Store asset ID for mini cakes
@@ -371,13 +371,18 @@
 			miniCake2.y = cake.y;
 			miniGameMiniCakes.push(miniCake1, miniCake2);
 			miniGameMiddlegroundContainer.addChild(miniCake1);
 			miniGameMiddlegroundContainer.addChild(miniCake2);
+			var index = miniGameCurrentCakes.indexOf(cake);
+			if (index !== -1) {
+				miniGameCurrentCakes.splice(index, 1);
+			}
 			cake.destroy();
 		});
 		var boundingBox = self.attachAsset('boundingBox', {
 			anchorX: 0.5,
-			anchorY: 0.5
+			anchorY: 0.5,
+			alpha: 0
 		});
 		cake.borderBox = boundingBox;
 		cake.addChild(boundingBox);
 		self.cakes.push(cake);
@@ -399,9 +404,9 @@
 			}
 		}
 	};
 	self.start = function () {
-		LK.setInterval(self.spawnCake, 2000);
+		LK.setInterval(self.spawnCake, 1000);
 	};
 });
 var Confetti = Container.expand(function (cakeIndex) {
 	var self = Container.call(this);
@@ -505,9 +510,9 @@
 	self.speedX = 7;
 	self.targetX = self.x;
 	self.lastX = self.x;
 	self.targetCooldown = 0; // Cooldown counter for changing targets
-	self.maxTargetCooldown = 15; // Réduit de 30 à 15 pour chercher des cibles plus souvent
+	self.maxTargetCooldown = 60; // 60 frames = 1 seconde à 60 FPS
 	self.idleTime = 0; // Compteur pour le temps d'inactivité
 	self.maxIdleTime = 30; // Temps maximum d'inactivité avant de chercher activement une cible
 	// Update function for movement and animation
 	self.update = function () {
@@ -628,28 +633,16 @@
 			}
 		});
 		// Check for intersection with non-miniCakes
 		if (self.state === 'empty' && !self.isSquashing) {
-			// Vérifier d'abord s'il y a réellement des gâteaux
-			if (miniGameCurrentCakes.length > 0) {
-				miniGameCurrentCakes.forEach(function (cake, index) {
-					// Vérifier que le gâteau existe, qu'il est dans une position valide,
-					// et que le nain n'est pas trop près du bord droit (où il vient d'être repositionné)
-					if (cake && cake.y < 2600 && self.x < 2000) {
-						// Utiliser notre méthode d'intersection personnalisée
-						if (self.intersects(cake.borderBox)) {
-							console.log("Intersection détectée avec gâteau:", {
-								nainX: self.x,
-								nainY: self.y,
-								cakeX: cake.x,
-								cakeY: cake.y
-							});
-							self.squashAnimation(cake);
-							return;
-						}
-					}
-				});
-			}
+			miniGameCurrentCakes.forEach(function (cake, index) {
+				//self.x >= cake.borderBox.x - cake.borderBox.width / 2 && self.x <= cake.borderBox.x + cake.borderBox.width / 2
+				if (cake && cake.y < 2500 && !cake.hasSquashed && self.intersects(cake.borderBox)) {
+					cake.hasSquashed = true; // Marquer le gâteau comme ayant déjà écrasé un nain
+					self.squashAnimation(cake);
+					return;
+				}
+			});
 		}
 		// Animate frames
 		self.animateFrames();
 		// Update lastX
@@ -657,8 +650,11 @@
 	};
 	self.searchForCakeInEmptyMode = function () {
 		// Chercher une nouvelle cible si le cooldown est terminé ou si la cible actuelle est invalide
 		if (self.targetCooldown === 0 || !self.currentTarget || self.currentTarget.y > 2732 + self.currentTarget.height / 2) {
+			if (self.currentTarget && Math.abs(self.x - self.currentTarget.x) < 5) {
+				self.jumpAnimation(); // Trigger jump animation when close to target cake
+			}
 			self.currentTarget = self.findClosestMiniCake() || self.findClosestFallingCake();
 			if (self.currentTarget) {
 				self.targetCooldown = self.maxTargetCooldown; // Reset cooldown
 				self.targetX = self.currentTarget.x;
@@ -726,44 +722,64 @@
 				cake.cakeIndex = Math.floor(Math.random() * 10000); // Générer un index unique
 			}
 			// Vérifier si ce gâteau est déjà ciblé par un autre nain
 			var isTargeted = false;
+			var isTooCrowded = false;
 			for (var j = 0; j < miniGameDwarfs.length; j++) {
+				var otherDwarf = miniGameDwarfs[j];
 				// Ne pas vérifier le nain actuel
-				if (miniGameDwarfs[j].dwarfIndex !== self.dwarfIndex && miniGameDwarfs[j].targetCakeIndex === cake.cakeIndex) {
-					isTargeted = true;
-					break;
+				if (otherDwarf.dwarfIndex !== self.dwarfIndex) {
+					// Vérifier si le gâteau est déjà ciblé
+					if (otherDwarf.targetCakeIndex === cake.cakeIndex) {
+						isTargeted = true;
+						break;
+					}
+					// Vérifier si un autre nain est déjà trop proche de ce gâteau
+					if (otherDwarf.targetCakeIndex !== -1 && Math.abs(otherDwarf.x - cake.x) < 300) {
+						isTooCrowded = true;
+						break;
+					}
 				}
 			}
-			// Si le gâteau n'est pas ciblé, l'ajouter aux gâteaux disponibles
-			if (!isTargeted) {
+			// Si le gâteau n'est pas ciblé et n'est pas trop proche d'un autre nain, l'ajouter aux gâteaux disponibles
+			if (!isTargeted && !isTooCrowded) {
 				availableCakeIndices.push(i); // Stocker l'index dans le tableau miniGameCurrentCakes
 			}
 		}
-		// S'il y a des gâteaux disponibles, en choisir un
+		// S'il y a des gâteaux disponibles, en choisir un AU HASARD
 		if (availableCakeIndices.length > 0) {
-			// Trouver le gâteau le plus proche parmi les disponibles
-			var closestCakeIndex = -1;
-			var minDistance = Infinity;
-			for (var k = 0; k < availableCakeIndices.length; k++) {
-				var cakeIndex = availableCakeIndices[k];
-				var availableCake = miniGameCurrentCakes[cakeIndex];
-				var dx = self.x - availableCake.x;
-				var dy = self.y - availableCake.y;
-				var distance = Math.sqrt(dx * dx + dy * dy);
-				if (distance < minDistance) {
-					minDistance = distance;
-					closestCakeIndex = cakeIndex;
+			// Sélectionner un gâteau au hasard parmi les disponibles
+			var randomIndex = Math.floor(Math.random() * availableCakeIndices.length);
+			var selectedCakeIndex = availableCakeIndices[randomIndex];
+			var selectedCake = miniGameCurrentCakes[selectedCakeIndex];
+			self.targetCakeIndex = selectedCake.cakeIndex;
+			return selectedCake;
+		}
+		// Si tous les gâteaux sont déjà ciblés ou trop proches d'autres nains,
+		// essayer de trouver un gâteau qui n'est pas ciblé, même s'il est proche d'un autre nain
+		availableCakeIndices = [];
+		for (var i = 0; i < miniGameCurrentCakes.length; i++) {
+			var cake = miniGameCurrentCakes[i];
+			var isTargeted = false;
+			for (var j = 0; j < miniGameDwarfs.length; j++) {
+				if (miniGameDwarfs[j].dwarfIndex !== self.dwarfIndex && miniGameDwarfs[j].targetCakeIndex === cake.cakeIndex) {
+					isTargeted = true;
+					break;
 				}
 			}
-			if (closestCakeIndex !== -1) {
-				var selectedCake = miniGameCurrentCakes[closestCakeIndex];
-				self.targetCakeIndex = selectedCake.cakeIndex;
-				return selectedCake;
+			if (!isTargeted) {
+				availableCakeIndices.push(i);
 			}
 		}
-		// Si tous les gâteaux sont déjà ciblés ou s'il n'y a pas de gâteau disponible,
-		// choisir le plus proche
+		// S'il y a des gâteaux non ciblés, en choisir un au hasard
+		if (availableCakeIndices.length > 0) {
+			var randomIndex = Math.floor(Math.random() * availableCakeIndices.length);
+			var selectedCakeIndex = availableCakeIndices[randomIndex];
+			var selectedCake = miniGameCurrentCakes[selectedCakeIndex];
+			self.targetCakeIndex = selectedCake.cakeIndex;
+			return selectedCake;
+		}
+		// Si tous les gâteaux sont déjà ciblés, choisir le plus proche
 		var closestCake = null;
 		var minDistance = Infinity;
 		miniGameCurrentCakes.forEach(function (cake) {
 			var dx = self.x - cake.x;
@@ -804,9 +820,9 @@
 		return closestMiniCake;
 	};
 	// Function to alternate frames for animation
 	self.animateFrames = function () {
-		if (self.x !== self.lastX) {
+		if (self.x !== self.lastX && !self.isSquashing) {
 			self.animationCounter++;
 			if (self.animationCounter >= self.animationDelay) {
 				if (self.state === 'full') {
 					if (dwarfFullFrame1.visible) {
@@ -831,75 +847,60 @@
 		self.currentFrame = dwarfFullFrame1.visible ? dwarfFullFrame1 : dwarfFullFrame2.visible ? dwarfFullFrame2 : dwarfEmptyFrame1.visible ? dwarfEmptyFrame1 : dwarfEmptyFrame2;
 		self.currentFrame.scaleX = self.speedX ? Math.sign(self.speedX) : 1;
 	};
 	self.squashAnimation = function (cake) {
-		// Vérifier que l'animation n'est pas déjà en cours et qu'un gâteau valide est fourni
-		if (self.isSquashing || !cake) {
+		if (self.isSquashing) {
 			return;
-		}
+		} // Prevent re-triggering if already squashing
 		self.isSquashing = true; // Set flag to indicate squash is in progress
 		tween(self.currentFrame, {
 			scaleY: 0
 		}, {
 			duration: 400,
 			easing: tween.easeInOut,
 			onFinish: function onFinish() {
-				// Repositionner le nain à droite de l'écran avec une position aléatoire
+				// Repositionner le nain à droite de l'écran
 				self.x = 2300 + Math.floor(Math.random() * 100);
-				// Réinitialiser l'état du nain
-				self.state = 'empty';
-				self.targetCakeIndex = -1;
-				self.targetCooldown = 0;
-				self.speedX = 7;
-				// Réinitialiser les frames d'animation
-				dwarfFullFrame1.visible = false;
-				dwarfFullFrame2.visible = false;
-				dwarfEmptyFrame1.visible = true;
-				dwarfEmptyFrame2.visible = false;
 				// Arrêter et faire disparaître le gâteau
-				if (cake && typeof cake.destroy === 'function') {
-					cake.speedY = 0;
-					tween(cake, {
-						alpha: 0
-					}, {
-						duration: 600,
-						easing: tween.easeOut,
-						onFinish: function onFinish() {
-							// Vérifier à nouveau que le gâteau existe toujours avant de le détruire
-							if (cake && typeof cake.destroy === 'function') {
-								cake.destroy(); // Remove the cake after it fades out
-							}
-						}
-					});
-				}
-				// Réinitialiser l'échelle du nain
-				tween(self.currentFrame, {
-					scaleY: 1
+				cake.speedY = 0;
+				tween(cake, {
+					alpha: 0
 				}, {
-					duration: 200,
-					easing: tween.easeInOut,
+					duration: 600,
+					easing: tween.easeOut,
 					onFinish: function onFinish() {
-						// Réinitialiser le flag d'écrasement seulement après que l'animation soit complètement terminée
-						self.isSquashing = false;
+						var index = miniGameCurrentCakes.indexOf(cake);
+						if (index !== -1) {
+							miniGameCurrentCakes.splice(index, 1);
+						}
+						cake.destroy(); // Remove the cake after it fades out
+						// Réinitialiser l'état du nain
+						self.state = 'empty';
+						self.targetCakeIndex = -1;
+						self.targetCooldown = 0;
+						self.animationCounter = 0;
+						self.speedX = 7;
+						// Réinitialiser les frames d'animation
+						dwarfFullFrame1.visible = false;
+						dwarfFullFrame2.visible = false;
+						dwarfEmptyFrame1.visible = true;
+						dwarfEmptyFrame2.visible = false;
+						// Réinitialiser l'échelle du nain
+						tween(self.currentFrame, {
+							scaleY: 1
+						}, {
+							duration: 10,
+							easing: tween.easeInOut,
+							onFinish: function onFinish() {
+								// Réinitialiser le flag d'écrasement seulement après que l'animation soit complètement terminée
+								self.isSquashing = false;
+							}
+						});
 					}
 				});
 			}
 		});
 	};
-	self.intersects = function (obj) {
-		// Calculer les limites du nain
-		var nainLeft = self.x - 40; // Approximation de la largeur/2
-		var nainRight = self.x + 40;
-		var nainTop = self.y - 80; // Approximation de la hauteur/2
-		var nainBottom = self.y + 80;
-		// Calculer les limites de l'objet
-		var objLeft = obj.x - obj.width / 2;
-		var objRight = obj.x + obj.width / 2;
-		var objTop = obj.y - obj.height / 2;
-		var objBottom = obj.y + obj.height / 2;
-		// Vérifier si les rectangles se chevauchent
-		return nainLeft < objRight && nainRight > objLeft && nainTop < objBottom && nainBottom > objTop;
-	};
 });
 var MiniCake = Container.expand(function (originalCake) {
 	var self = Container.call(this);
 	var miniCakeGraphics = self.attachAsset(originalCake.assetId, {
@@ -1435,9 +1436,9 @@
 var miniGamebackground;
 var switchButtonMini;
 var chef;
 var miniGameDwarfs = []; // Variable globale pour stocker les nains
-var miniGameDwarfCount = 1; //3; // Nombre de nains à créer
+var miniGameDwarfCount = 3; // Nombre de nains à créer
 var miniGameCurrentCakes = []; // Global array to store falling cakes
 var miniGameMiniCakes = []; // Global array to track mini cakes
 function toggleMiniGame() {
 	if (isMiniGameRunning) {
@@ -1620,5 +1621,27 @@
 	cakeRainManager.start();
 }
 // Call the function to initialize game variables
 initializeGameVariables();
-initializeminiGameVariables();
\ No newline at end of file
+initializeminiGameVariables();
+self.jumpAnimation = function () {
+	if (!self.jumpPlayed) {
+		var baseY = self.y;
+		tween(self, {
+			y: baseY - 50
+		}, {
+			duration: 200,
+			easing: tween.easeInOut,
+			onFinish: function onFinish() {
+				tween(self, {
+					y: baseY
+				}, {
+					duration: 200,
+					easing: tween.easeInOut,
+					onFinish: function onFinish() {
+						self.jumpPlayed = true; // Mark the jump animation as played
+					}
+				});
+			}
+		});
+	}
+};
\ No newline at end of file