===================================================================
--- original.js
+++ change.js
@@ -229,8 +229,9 @@
 			});
 			LK.getSound('errorsond').play(); // Play error sound
 		}
 	};
+	return self;
 });
 // BigCake class
 var BigCake = Container.expand(function () {
 	var self = Container.call(this);
@@ -337,14 +338,62 @@
 	};
 	self.start = function () {
 		function triggerPopBonus() {
 			self.popBonus();
-			var randomInterval = 120000 + Math.random() * 120000; // Random interval between 3min (180000ms) and 6min (360000ms)
+			var randomInterval = 120000 + Math.random() * 60000; // Random interval between 3min (180000ms) and 6min (360000ms)
 			LK.setTimeout(triggerPopBonus, randomInterval);
 		}
 		triggerPopBonus();
 	};
 });
+// Chef character (player)
+var ChefCharacter = Container.expand(function () {
+	var self = Container.call(this);
+	// Chef graphics
+	var chefGraphics = self.attachAsset('chef', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// Chef position and movement variables
+	self.speed = 15;
+	self.position = {
+		x: 2048 / 2,
+		y: 2732 - 150
+	};
+	self.targetX = self.position.x;
+	// Add a shadow effect
+	var shadow = new Graphics();
+	shadow.beginFill(0x000000, 0.3);
+	shadow.drawEllipse(0, 10, 60, 20);
+	shadow.endFill();
+	shadow.y = chefGraphics.height / 2 - 10;
+	self.addChild(shadow);
+	// Add chef after shadow (layering)
+	self.addChild(chefGraphics);
+	// Update function for movement
+	self.update = function () {
+		// Only update if in mini-game mode
+		if (!isMiniGameMode) {
+			return;
+		}
+		// Move towards target position with smooth movement
+		self.position.x += (self.targetX - self.position.x) * 0.2;
+		self.x = self.position.x;
+		self.y = self.position.y;
+		// Animate chef slightly based on movement
+		var movementSpeed = Math.abs(self.targetX - self.position.x);
+		if (movementSpeed > 1) {
+			chefGraphics.rotation = (self.targetX > self.position.x ? 1 : -1) * Math.min(movementSpeed * 0.001, 0.1);
+		} else {
+			chefGraphics.rotation = 0;
+		}
+	};
+	// Handle touch/mouse input
+	self.setTargetPosition = function (x) {
+		self.targetX = Math.max(50, Math.min(2048 - 50, x));
+	};
+	return self;
+});
 var Confetti = Container.expand(function (cakeIndex) {
 	var self = Container.call(this);
 	cakeIndex = cakeIndex ? cakeIndex : 0;
 	var confettiGraphics = self.attachAsset('cake_' + Math.max(0, Math.min(cakeIndex, 9)), {
@@ -366,19 +415,544 @@
 			self.destroy();
 		}
 	};
 });
+// Confetti manager for visual effects
 var ConfettiManager = Container.expand(function () {
 	var self = Container.call(this);
-	self.popCakes = function (x, y, numConfetti) {
-		for (var i = 0; i < numConfetti; i++) {
-			var confetti = middleContainer.addChild(new Confetti(upgradeLevel));
-			confetti.x = x;
-			confetti.y = y;
-			confetti.speedY = -15; // Initial upward speed 
+	self.particles = [];
+	// Pop confetti effect
+	self.popCakes = function (x, y, count) {
+		for (var i = 0; i < count; i++) {
+			var particle = new Container();
+			// Random cake type for confetti
+			var cakeIndex = Math.floor(Math.random() * 10);
+			var particleGraphics = particle.attachAsset('cake_' + cakeIndex, {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+			// Scale down for confetti effect
+			particle.scale.set(0.3 + Math.random() * 0.2);
+			// Random position around the catch point
+			particle.x = x;
+			particle.y = y;
+			// Random velocity
+			particle.vx = (Math.random() - 0.5) * 10;
+			particle.vy = -5 - Math.random() * 5;
+			// Random rotation
+			particle.rotation = Math.random() * Math.PI * 2;
+			particle.vr = (Math.random() - 0.5) * 0.2;
+			self.addChild(particle);
+			self.particles.push(particle);
 		}
+		// Start update loop if not already running
+		if (!self.updateInterval) {
+			self.updateInterval = LK.setInterval(function () {
+				self.update();
+			}, 16); // ~60fps
+		}
 	};
+	// Update all particles
+	self.update = function () {
+		var gravity = 0.2;
+		var friction = 0.98;
+		for (var i = self.particles.length - 1; i >= 0; i--) {
+			var particle = self.particles[i];
+			// Apply gravity
+			particle.vy += gravity;
+			// Apply friction
+			particle.vx *= friction;
+			particle.vy *= friction;
+			// Update position
+			particle.x += particle.vx;
+			particle.y += particle.vy;
+			// Update rotation
+			particle.rotation += particle.vr;
+			// Fade out
+			particle.alpha -= 0.01;
+			// Remove if faded out or off screen
+			if (particle.alpha <= 0 || particle.y > 2732 + 50) {
+				self.removeChild(particle);
+				self.particles.splice(i, 1);
+			}
+		}
+		// Stop update loop if no particles left
+		if (self.particles.length === 0) {
+			LK.clearInterval(self.updateInterval);
+			self.updateInterval = null;
+			self.destroy();
+		}
+	};
+	return self;
 });
+// Falling Cake class
+var FallingCake = Container.expand(function () {
+	var self = Container.call(this);
+	// Random cake type (0-9)
+	var cakeIndex = Math.floor(Math.random() * 10);
+	// Cake graphics
+	var cakeGraphics = self.attachAsset('cake_' + cakeIndex, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// Add rotation animation
+	var rotationDirection = Math.random() > 0.5 ? 1 : -1;
+	var rotationSpeed = (Math.random() * 0.02 + 0.01) * rotationDirection;
+	// Cake properties
+	self.speed = 5 + Math.random() * 3;
+	self.value = (cakeIndex + 1) * 10; // Value based on cake type
+	self.active = true;
+	self.cakeType = cakeIndex;
+	// Special cakes (rare)
+	if (Math.random() < 0.05) {
+		// 5% chance for special cake
+		self.isSpecial = true;
+		self.value *= 5;
+		cakeGraphics.tint = 0xFFD700; // Gold tint for special cakes
+		// Add sparkle effect
+		var _sparkle = function sparkle() {
+			if (!self.active) {
+				return;
+			}
+			var sparkleEffect = new Container();
+			var sparkleGraphics = sparkleEffect.attachAsset('etoile', {
+				anchorX: 0.5,
+				anchorY: 0.5,
+				alpha: 0.8
+			});
+			sparkleEffect.x = (Math.random() - 0.5) * cakeGraphics.width;
+			sparkleEffect.y = (Math.random() - 0.5) * cakeGraphics.height;
+			sparkleEffect.scale.set(0.5 + Math.random() * 0.5);
+			self.addChild(sparkleEffect);
+			tween(sparkleEffect, {
+				alpha: 0,
+				scaleX: 0,
+				scaleY: 0
+			}, {
+				duration: 500,
+				easing: tween.easeOut,
+				onFinish: function onFinish() {
+					self.removeChild(sparkleEffect);
+					sparkleEffect.destroy();
+				}
+			});
+			if (self.active) {
+				LK.setTimeout(_sparkle, 300 + Math.random() * 300);
+			}
+		};
+		_sparkle();
+	}
+	// Update function for falling
+	self.update = function () {
+		if (!self.active || !isMiniGameMode) {
+			return;
+		}
+		self.y += self.speed;
+		cakeGraphics.rotation += rotationSpeed;
+		// Check if cake is out of bounds
+		if (self.y > 2732 + 50) {
+			self.active = false;
+		}
+	};
+	// Destroy function
+	self.destroy = function () {
+		self.active = false;
+		Container.prototype.destroy.call(self);
+	};
+	return self;
+});
+// Mini-Game Button class
+var MiniGameButton = Container.expand(function () {
+	var self = Container.call(this);
+	// Button graphics with shadow effect
+	var shadowGraphics = self.attachAsset('buttonPrice', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	shadowGraphics.tint = 0x000000;
+	shadowGraphics.alpha = 0.5;
+	shadowGraphics.y = 10;
+	self.addChild(shadowGraphics);
+	var buttonGraphics = self.attachAsset('buttonPrice', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// Add a chef icon to the button
+	var chefIcon = self.attachAsset('chef', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		width: 60,
+		height: 92
+	});
+	chefIcon.y = -20;
+	self.addChild(chefIcon);
+	// Button text
+	var buttonText = new Text2('MINI-GAME', {
+		size: 30,
+		fill: 0xFFFFFF,
+		fontWeight: '900',
+		dropShadow: true,
+		dropShadowColor: 0x000000,
+		dropShadowBlur: 5,
+		dropShadowDistance: 5
+	});
+	buttonText.anchor.set(0.5, 0.5);
+	buttonText.y = 40;
+	self.addChild(buttonText);
+	// Click handler
+	self.onClick = function () {
+		// Only allow switching if not already in mini-game mode
+		if (!isMiniGameMode) {
+			// Play sound
+			LK.getSound('clickSound').play();
+			// Switch to mini-game mode
+			switchToMiniGame();
+			// Button animation
+			tween(buttonGraphics, {
+				scaleX: 0.9,
+				scaleY: 0.9
+			}, {
+				duration: 100,
+				easing: tween.easeInOut,
+				onFinish: function onFinish() {
+					tween(buttonGraphics, {
+						scaleX: 1,
+						scaleY: 1
+					}, {
+						duration: 100,
+						easing: tween.easeInOut
+					});
+				}
+			});
+		}
+	};
+	return self;
+});
+// Cake Manager for mini-game
+var MiniGameCakeManager = Container.expand(function () {
+	var self = Container.call(this);
+	self.cakes = [];
+	self.spawnInterval = null;
+	self.spawnRate = 1000; // ms between cake spawns
+	self.difficultyTimer = 0;
+	self.gameScore = 0;
+	self.combo = 0;
+	self.comboTimer = null;
+	// Start spawning cakes
+	self.start = function () {
+		self.spawnInterval = LK.setInterval(function () {
+			if (isMiniGameMode) {
+				self.spawnCake();
+			}
+		}, self.spawnRate);
+		// Increase difficulty over time
+		self.difficultyTimer = LK.setInterval(function () {
+			if (isMiniGameMode) {
+				self.spawnRate = Math.max(300, self.spawnRate - 50);
+				LK.clearInterval(self.spawnInterval);
+				self.spawnInterval = LK.setInterval(function () {
+					if (isMiniGameMode) {
+						self.spawnCake();
+					}
+				}, self.spawnRate);
+			}
+		}, 10000); // Increase difficulty every 10 seconds
+	};
+	// Stop spawning cakes
+	self.stop = function () {
+		LK.clearInterval(self.spawnInterval);
+		LK.clearInterval(self.difficultyTimer);
+		LK.clearInterval(self.comboTimer);
+		// Clear all cakes
+		self.cakes.forEach(function (cake) {
+			cake.destroy();
+		});
+		self.cakes = [];
+	};
+	// Spawn a new cake
+	self.spawnCake = function () {
+		var cake = new FallingCake();
+		cake.x = 50 + Math.random() * (2048 - 100); // Random x position
+		cake.y = -50; // Start above screen
+		self.addChild(cake);
+		self.cakes.push(cake);
+	};
+	// Update all cakes and check collisions
+	self.update = function (chef) {
+		if (!isMiniGameMode) {
+			return;
+		}
+		// Update each cake
+		for (var i = self.cakes.length - 1; i >= 0; i--) {
+			var cake = self.cakes[i];
+			if (!cake.active) {
+				self.cakes.splice(i, 1);
+				continue;
+			}
+			cake.update();
+			// Check collision with chef
+			if (self.checkCollision(cake, chef)) {
+				// Calculate score with combo
+				var points = cake.value * (1 + self.combo * 0.1);
+				self.gameScore += Math.floor(points);
+				// Increment combo
+				self.combo++;
+				// Reset combo timer
+				LK.clearTimeout(self.comboTimer);
+				self.comboTimer = LK.setTimeout(function () {
+					self.combo = 0;
+				}, 2000);
+				// Play catch sound
+				LK.getSound('clickSound').play();
+				// Create score popup
+				self.createScorePopup(cake.x, cake.y, Math.floor(points), cake.isSpecial);
+				// Create effect at catch position
+				var effect = new ConfettiManager();
+				effect.popCakes(cake.x, cake.y, cake.isSpecial ? 10 : 5);
+				miniGameContainer.addChild(effect);
+				// Remove cake
+				cake.destroy();
+				self.cakes.splice(i, 1);
+			}
+		}
+	};
+	// Create score popup
+	self.createScorePopup = function (x, y, score, isSpecial) {
+		var popup = new Text2('+' + score, {
+			size: isSpecial ? 60 : 40,
+			fill: isSpecial ? 0xFFD700 : 0xFFFFFF,
+			fontWeight: '900',
+			dropShadow: true,
+			dropShadowColor: 0x000000,
+			dropShadowBlur: 5,
+			dropShadowDistance: 5
+		});
+		popup.anchor.set(0.5, 0.5);
+		popup.x = x;
+		popup.y = y;
+		self.addChild(popup);
+		tween(popup, {
+			y: popup.y - 80,
+			alpha: 0
+		}, {
+			duration: 1000,
+			easing: tween.easeOut,
+			onFinish: function onFinish() {
+				self.removeChild(popup);
+				popup.destroy();
+			}
+		});
+	};
+	// Simple collision detection
+	self.checkCollision = function (cake, chef) {
+		var dx = Math.abs(cake.x - chef.position.x);
+		var dy = Math.abs(cake.y - chef.position.y);
+		return dx < 70 && dy < 100; // Adjust collision box as needed
+	};
+	return self;
+});
+// UI for mini-game
+var MiniGameUI = Container.expand(function () {
+	var self = Container.call(this);
+	// Background panel
+	var panel = new Graphics();
+	panel.beginFill(0x000000, 0.5);
+	panel.drawRoundedRect(0, 0, 400, 150, 20);
+	panel.endFill();
+	panel.x = 2048 / 2 - 200;
+	panel.y = 20;
+	self.addChild(panel);
+	// Score text
+	var scoreLabel = new Text2('Score:', {
+		size: 30,
+		fill: 0xFFFFFF,
+		fontWeight: '900'
+	});
+	scoreLabel.x = panel.x + 20;
+	scoreLabel.y = panel.y + 20;
+	self.addChild(scoreLabel);
+	var scoreText = new Text2('0', {
+		size: 30,
+		fill: 0xFFFFFF,
+		fontWeight: '900'
+	});
+	scoreText.x = panel.x + 200;
+	scoreText.y = panel.y + 20;
+	self.addChild(scoreText);
+	// Combo text
+	var comboLabel = new Text2('Combo:', {
+		size: 30,
+		fill: 0xFFFFFF,
+		fontWeight: '900'
+	});
+	comboLabel.x = panel.x + 20;
+	comboLabel.y = panel.y + 60;
+	self.addChild(comboLabel);
+	var comboText = new Text2('x1', {
+		size: 30,
+		fill: 0xFFFFFF,
+		fontWeight: '900'
+	});
+	comboText.x = panel.x + 200;
+	comboText.y = panel.y + 60;
+	self.addChild(comboText);
+	// Time text
+	var timeLabel = new Text2('Time:', {
+		size: 30,
+		fill: 0xFFFFFF,
+		fontWeight: '900'
+	});
+	timeLabel.x = panel.x + 20;
+	timeLabel.y = panel.y + 100;
+	self.addChild(timeLabel);
+	var timeText = new Text2('60s', {
+		size: 30,
+		fill: 0xFFFFFF,
+		fontWeight: '900'
+	});
+	timeText.x = panel.x + 200;
+	timeText.y = panel.y + 100;
+	self.addChild(timeText);
+	// Update UI
+	self.update = function (score, combo, timeRemaining) {
+		scoreText.text = score.toString();
+		comboText.text = 'x' + (combo + 1).toString();
+		timeText.text = timeRemaining + 's';
+		// Pulse combo text when combo increases
+		if (combo > 0) {
+			comboText.tint = 0xFFD700; // Gold color for combo
+			tween(comboText, {
+				scaleX: 1.2,
+				scaleY: 1.2
+			}, {
+				duration: 100,
+				easing: tween.easeOut,
+				onFinish: function onFinish() {
+					tween(comboText, {
+						scaleX: 1,
+						scaleY: 1
+					}, {
+						duration: 100,
+						easing: tween.easeIn
+					});
+				}
+			});
+		} else {
+			comboText.tint = 0xFFFFFF;
+		}
+		// Warning color when time is low
+		if (timeRemaining <= 10) {
+			timeText.tint = 0xFF0000;
+			// Pulse time text
+			if (timeRemaining % 2 === 0) {
+				tween(timeText, {
+					scaleX: 1.2,
+					scaleY: 1.2
+				}, {
+					duration: 300,
+					easing: tween.easeOut,
+					onFinish: function onFinish() {
+						tween(timeText, {
+							scaleX: 1,
+							scaleY: 1
+						}, {
+							duration: 300,
+							easing: tween.easeIn
+						});
+					}
+				});
+			}
+		} else {
+			timeText.tint = 0xFFFFFF;
+		}
+	};
+	// Results screen
+	self.showResults = function (score, reward) {
+		// Create results panel
+		var resultsPanel = new Graphics();
+		resultsPanel.beginFill(0x000000, 0.8);
+		resultsPanel.drawRoundedRect(0, 0, 800, 600, 30);
+		resultsPanel.endFill();
+		resultsPanel.x = 2048 / 2 - 400;
+		resultsPanel.y = 2732 / 2 - 300;
+		self.addChild(resultsPanel);
+		// Results title
+		var titleText = new Text2('GAME OVER!', {
+			size: 60,
+			fill: 0xFFFFFF,
+			fontWeight: '900',
+			dropShadow: true,
+			dropShadowColor: 0x000000,
+			dropShadowBlur: 5,
+			dropShadowDistance: 5
+		});
+		titleText.anchor.set(0.5, 0);
+		titleText.x = 2048 / 2;
+		titleText.y = resultsPanel.y + 50;
+		self.addChild(titleText);
+		// Score result
+		var scoreResultText = new Text2('Your Score: ' + score, {
+			size: 40,
+			fill: 0xFFFFFF,
+			fontWeight: '900'
+		});
+		scoreResultText.anchor.set(0.5, 0);
+		scoreResultText.x = 2048 / 2;
+		scoreResultText.y = resultsPanel.y + 150;
+		self.addChild(scoreResultText);
+		// Reward result
+		var rewardResultText = new Text2('Cake Reward: ' + reward, {
+			size: 40,
+			fill: 0xFFD700,
+			fontWeight: '900'
+		});
+		rewardResultText.anchor.set(0.5, 0);
+		rewardResultText.x = 2048 / 2;
+		rewardResultText.y = resultsPanel.y + 220;
+		self.addChild(rewardResultText);
+		// Continue button
+		var continueButton = new Container();
+		var buttonGraphics = new Graphics();
+		buttonGraphics.beginFill(0x4CAF50);
+		buttonGraphics.drawRoundedRect(0, 0, 300, 80, 15);
+		buttonGraphics.endFill();
+		continueButton.addChild(buttonGraphics);
+		var buttonText = new Text2('CONTINUE', {
+			size: 40,
+			fill: 0xFFFFFF,
+			fontWeight: '900'
+		});
+		buttonText.anchor.set(0.5, 0.5);
+		buttonText.x = 150;
+		buttonText.y = 40;
+		continueButton.addChild(buttonText);
+		continueButton.x = 2048 / 2 - 150;
+		continueButton.y = resultsPanel.y + 400;
+		continueButton.interactive = true;
+		continueButton.buttonMode = true;
+		continueButton.on('pointerdown', function () {
+			// Play sound
+			LK.getSound('clickSound').play();
+			// Return to main game
+			switchToMainGame();
+			// Remove results screen
+			self.removeChild(resultsPanel);
+			self.removeChild(titleText);
+			self.removeChild(scoreResultText);
+			self.removeChild(rewardResultText);
+			self.removeChild(continueButton);
+		});
+		self.addChild(continueButton);
+		// Button hover effect
+		continueButton.on('pointerover', function () {
+			buttonGraphics.tint = 0x3E8E41;
+		});
+		continueButton.on('pointerout', function () {
+			buttonGraphics.tint = 0xFFFFFF;
+		});
+	};
+	return self;
+});
 // ResetButton class
 var ResetButton = Container.expand(function () {
 	var self = Container.call(this);
 	var resetButtonGraphics = self.attachAsset('resetButton', {
@@ -497,200 +1071,131 @@
 });
 // Upgrade class
 var Upgrade = Container.expand(function () {
 	var self = Container.call(this);
-	// Create a shadow effect by adding a black tinted, semi-transparent duplicate of upgradeGraphics
-	var shadowGraphics = self.attachAsset('upgrade', {
+	// Upgrade properties
+	self.id = '';
+	self.name = '';
+	self.description = '';
+	self.price = 0;
+	self.cakesPerSecondIncrease = 0;
+	self.cakesPerClickIncrease = 0;
+	self.level = 0;
+	// Upgrade graphics
+	var upgradeGraphics = self.attachAsset('buttonPrice', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
-	shadowGraphics.tint = 0x000000; // Tint the shadow black
-	shadowGraphics.alpha = 0.5; // Make the shadow semi-transparent
-	shadowGraphics.y = 10; // Position the shadow slightly below the upgrade button
-	self.addChild(shadowGraphics);
-	var upgradeGraphics = self.attachAsset('upgrade', {
+	// Upgrade icon
+	var icon = self.attachAsset('cake_0', {
 		anchorX: 0.5,
-		anchorY: 0.5
+		anchorY: 0.5,
+		width: 60,
+		height: 60
 	});
-	// Attach the cake_1 image on top of the upgrade button
-	self.cakeGraphics = self.attachAsset('cake_1', {
-		anchorX: 0.5,
-		anchorY: 0.5
+	icon.x = -120;
+	self.addChild(icon);
+	// Upgrade name text
+	var nameText = new Text2('Upgrade', {
+		size: 30,
+		fill: 0xFFFFFF,
+		fontWeight: '900'
 	});
-	self.cakeGraphics.y = -10; // Move the cake slightly higher on the upgrade button
-	self.addChild(self.cakeGraphics);
-	var upgradesLabel = new Text2('Upgrades', {
-		size: 60,
-		fill: 0x808080,
-		// Gray color
+	nameText.anchor.set(0, 0.5);
+	nameText.x = -80;
+	nameText.y = -20;
+	self.addChild(nameText);
+	// Upgrade description text
+	var descriptionText = new Text2('Description', {
+		size: 20,
+		fill: 0xFFFFFF
+	});
+	descriptionText.anchor.set(0, 0.5);
+	descriptionText.x = -80;
+	descriptionText.y = 10;
+	self.addChild(descriptionText);
+	// Upgrade price text
+	var priceText = new Text2('100', {
+		size: 30,
+		fill: 0xFFFFFF,
 		fontWeight: '900'
 	});
-	upgradesLabel.anchor.set(0.5, 1); // Center the text horizontally and align it to the bottom
-	upgradesLabel.y = self.cakeGraphics.y - self.cakeGraphics.height / 2 - 160; // Move text slightly higher above the cake image
-	upgradesLabel.fill = 0x808080; // Change text color to gray
-	self.addChild(upgradesLabel);
-	var upgradeLabel = new Text2('Cake', {
-		size: 60,
-		fill: 0xFF8C00,
-		// Dark orange color
-		fontWeight: '900',
-		dropShadow: true,
-		dropShadowColor: 0x000000,
-		dropShadowBlur: 5,
-		dropShadowDistance: 5
+	priceText.anchor.set(0.5, 0.5);
+	priceText.x = 120;
+	self.addChild(priceText);
+	// Upgrade level text
+	var levelText = new Text2('Lv. 0', {
+		size: 20,
+		fill: 0xFFFFFF
 	});
-	upgradeLabel.anchor.set(0.5, 1); // Center the text horizontally and align it to the bottom
-	upgradeLabel.y = self.cakeGraphics.y - self.cakeGraphics.height / 2 - 50; // Position text even higher above the cake image
-	self.addChild(upgradeLabel);
-	self.cost = 10; // Initial cost of the upgrade
-	self.multiplier = 1; // Score multiplier
-	self.updateCost = function () {
-		self.cost = upgradePrices[Math.min(upgradeLevel + 1, upgradePrices.length - 1)]; // Update the cost using the upgradePrices array
-		storage.upgradeCost = self.cost; // Save the updated upgrade cost
+	levelText.anchor.set(0.5, 0.5);
+	levelText.x = 120;
+	levelText.y = 30;
+	self.addChild(levelText);
+	// Initialize upgrade
+	self.initialize = function (id, name, description, basePrice, cakesPerSecondIncrease, cakesPerClickIncrease, iconAsset) {
+		self.id = id;
+		self.name = name;
+		self.description = description;
+		self.basePrice = basePrice;
+		self.price = basePrice;
+		self.cakesPerSecondIncrease = cakesPerSecondIncrease;
+		self.cakesPerClickIncrease = cakesPerClickIncrease;
+		self.level = 0;
+		// Update texts
+		nameText.text = name;
+		descriptionText.text = description;
+		priceText.text = basePrice;
+		levelText.text = 'Lv. ' + self.level;
+		// Update icon
+		if (iconAsset) {
+			self.removeChild(icon);
+			icon = self.attachAsset(iconAsset, {
+				anchorX: 0.5,
+				anchorY: 0.5,
+				width: 60,
+				height: 60
+			});
+			icon.x = -120;
+			self.addChild(icon);
+		}
+		return self;
 	};
-	self.increaseMultiplier = function () {
-		self.multiplier += 1; // Increase the multiplier by 1
+	// Update upgrade price based on level
+	self.updatePrice = function () {
+		self.price = Math.floor(self.basePrice * Math.pow(1.15, self.level));
+		priceText.text = self.price;
 	};
-	var upgradeText = new Text2('$' + self.cost, {
-		size: 80,
-		fill: 0xFFA500,
-		// Orange color
-		fontWeight: '900',
-		dropShadow: true,
-		dropShadowColor: 0x000000,
-		dropShadowBlur: 5,
-		dropShadowDistance: 5
-	});
-	upgradeText.anchor.set(0.5, 0);
-	upgradeText.x = 0;
-	upgradeText.y = upgradeGraphics.height / 2 + 20; // Position text below the upgrade button
-	self.addChild(upgradeText);
-	self.updateUpgradeText = function () {
-		upgradeText.setText(formatPrice(self.cost));
-	};
-	self.updateCakeGraphics = function () {
-		var cakeIndex = Math.min(upgradeLevel + 1, 9);
-		tween(self.cakeGraphics, {
-			alpha: 0
-		}, {
-			duration: 500,
-			easing: tween.easeOut,
-			onFinish: function onFinish() {
-				self.removeChild(self.cakeGraphics);
-				self.cakeGraphics = self.attachAsset('cake_' + cakeIndex, {
-					anchorX: 0.5,
-					anchorY: 0.5
-				});
-				self.cakeGraphics.y = -10;
-				self.cakeGraphics.alpha = 0;
-				self.addChild(self.cakeGraphics);
-				tween(self.cakeGraphics, {
-					alpha: 1
-				}, {
-					duration: 500,
-					easing: tween.easeIn
-				});
-			}
-		});
-	};
-	self.onClick = function () {
-		if (currentScore >= self.cost) {
-			currentScore -= self.cost; // Deduct the cost from the current score
-			score.updateScore(currentScore); // Update the score display
-			self.updateCost(); // Update the cost for the next upgrade
-			storage.upgradeMultiplier = self.multiplier; // Save the updated multiplier
-			self.increaseMultiplier(); // Increase the score multiplier
-			self.updateUpgradeText(); // Update the upgrade text
-			upgradeLevel = Math.min(upgradeLevel + 1, 9); // Increment upgrade level, max 9
-			storage.upgradeLevel = upgradeLevel; // Save the updated upgrade level
-			self.updateCakeGraphics(); // Update cake graphics based on new upgrade level
-			confettiManager.popCakes(bigCake.x, bigCake.y, 5); // Call popCakes using bigCake's coordinates
-			LK.getSound('buySound').play(); // Play buy sound when upgrade is purchased
-			// Animate the upgrade button
-			tween(upgradeGraphics, {
-				scaleX: 0.9,
-				scaleY: 0.9
-			}, {
-				duration: 100,
-				easing: tween.easeInOut,
-				onFinish: function onFinish() {
-					tween(upgradeGraphics, {
-						scaleX: 1,
-						scaleY: 1
-					}, {
-						duration: 100,
-						easing: tween.easeInOut
-					});
-				}
-			});
-			// Animate the shadowGraphics in the same way
-			tween(shadowGraphics, {
-				scaleX: 0.9,
-				scaleY: 0.9
-			}, {
-				duration: 100,
-				easing: tween.easeInOut,
-				onFinish: function onFinish() {
-					tween(shadowGraphics, {
-						scaleX: 1,
-						scaleY: 1
-					}, {
-						duration: 100,
-						easing: tween.easeInOut
-					});
-				}
-			});
-			// Animate the cakeGraphics in the same way
-			tween(self.cakeGraphics, {
-				scaleX: 0.9,
-				scaleY: 0.9
-			}, {
-				duration: 100,
-				easing: tween.easeInOut,
-				onFinish: function onFinish() {
-					tween(self.cakeGraphics, {
-						scaleX: 1,
-						scaleY: 1
-					}, {
-						duration: 100,
-						easing: tween.easeInOut
-					});
-				}
-			});
+	// Buy upgrade
+	self.buy = function () {
+		// Check if player has enough cakes
+		if (cakes >= self.price) {
+			// Subtract price from cakes
+			cakes -= self.price;
+			updateCakeCounter();
+			// Increase level
+			self.level++;
+			levelText.text = 'Lv. ' + self.level;
+			// Update price
+			self.updatePrice();
+			// Increase cakes per second
+			cakesPerSecond += self.cakesPerSecondIncrease;
+			updateCakesPerSecondCounter();
+			// Increase cakes per click
+			cakesPerClick += self.cakesPerClickIncrease;
+			// Play purchase sound
+			LK.getSound('achat').play();
+			// Create animation
+			var animation = new CakeAnimation();
+			animation.x = self.x;
+			animation.y = self.y;
+			foregroundContainer.addChild(animation);
 		} else {
-			tween(self, {
-				alpha: 0.2
-			}, {
-				duration: 100,
-				easing: tween.easeInOut,
-				onFinish: function onFinish() {
-					tween(self, {
-						alpha: 1
-					}, {
-						duration: 100,
-						easing: tween.easeInOut,
-						onFinish: function onFinish() {
-							tween(self, {
-								alpha: 0.2
-							}, {
-								duration: 100,
-								easing: tween.easeInOut,
-								onFinish: function onFinish() {
-									tween(self, {
-										alpha: 1
-									}, {
-										duration: 100,
-										easing: tween.easeInOut
-									});
-								}
-							});
-						}
-					});
-				}
-			});
+			// Not enough cakes
 			LK.getSound('errorsond').play(); // Play error sound
 		}
 	};
+	return self;
 });
 
 /**** 
 * Initialize Game
@@ -852,8 +1357,90 @@
 var autoClickerText;
 var bigCake;
 var resetButton;
 var board;
+// Mini-game global variables
+var isMiniGameMode = false; // Controls which game mode is active
+var miniGameContainer; // Container for the mini-game
+var miniGameChef;
+var miniGameCakeManager;
+var miniGameUI;
+var miniGameTimer;
+var miniGameDuration = 60; // 60 seconds
+var miniGameTimeRemaining;
+var miniGameReward = 0;
+// Switch to mini-game mode
+function switchToMiniGame() {
+	if (isMiniGameMode) {
+		return;
+	}
+	isMiniGameMode = true;
+	// Move main game containers off-screen (instead of hiding them)
+	// This preserves the game state while making them invisible
+	backgroundContainer.x = -5000;
+	middleContainer.x = -5000;
+	foregroundContainer.x = -5000;
+	// Show mini-game container
+	miniGameContainer.visible = true;
+	// Reset mini-game variables
+	miniGameTimeRemaining = miniGameDuration;
+	miniGameCakeManager.gameScore = 0;
+	miniGameCakeManager.combo = 0;
+	// Start mini-game
+	miniGameCakeManager.start();
+	// Start timer
+	miniGameTimer = LK.setInterval(function () {
+		miniGameTimeRemaining--;
+		// Update UI
+		miniGameUI.update(miniGameCakeManager.gameScore, miniGameCakeManager.combo, miniGameTimeRemaining);
+		// Check if game is over
+		if (miniGameTimeRemaining <= 0) {
+			endMiniGame();
+		}
+	}, 1000);
+	// Set up input handling for mini-game
+	LK.stage.on('pointermove', handleMiniGamePointerMove);
+	LK.stage.on('pointerdown', handleMiniGamePointerMove);
+}
+// Handle mini-game pointer movement
+function handleMiniGamePointerMove(event) {
+	if (!isMiniGameMode) {
+		return;
+	}
+	var position = event.data.global;
+	miniGameChef.setTargetPosition(position.x);
+}
+// End mini-game
+function endMiniGame() {
+	// Stop timer
+	LK.clearInterval(miniGameTimer);
+	// Stop cake manager
+	miniGameCakeManager.stop();
+	// Remove input handlers
+	LK.stage.off('pointermove', handleMiniGamePointerMove);
+	LK.stage.off('pointerdown', handleMiniGamePointerMove);
+	// Calculate reward based on score
+	miniGameReward = Math.floor(miniGameCakeManager.gameScore / 10);
+	// Add reward to player's cakes
+	cakes += miniGameReward;
+	// Show results screen
+	miniGameUI.showResults(miniGameCakeManager.gameScore, miniGameReward);
+}
+// Switch back to main game
+function switchToMainGame() {
+	if (!isMiniGameMode) {
+		return;
+	}
+	isMiniGameMode = false;
+	// Move main game containers back to original position
+	backgroundContainer.x = 0;
+	middleContainer.x = 0;
+	foregroundContainer.x = 0;
+	// Hide mini-game container
+	miniGameContainer.visible = false;
+	// Update main game UI to reflect new cake count
+	updateCakeCounter();
+}
 // Initialize game variables
 function initializeGameVariables() {
 	backgroundContainer = new Container();
 	game.addChild(backgroundContainer);
@@ -945,7 +1532,49 @@
 	// Play bakery music in a loop throughout the game
 	LK.playMusic('musiqueclicker', {
 		loop: true
 	});
+	// Initialize mini-game container
+	miniGameContainer = new Container();
+	miniGameContainer.visible = false;
+	game.addChild(miniGameContainer);
+	// Initialize mini-game UI
+	miniGameUI = new MiniGameUI();
+	miniGameContainer.addChild(miniGameUI);
+	// Initialize mini-game chef
+	miniGameChef = new ChefCharacter();
+	miniGameContainer.addChild(miniGameChef);
+	// Initialize mini-game cake manager
+	miniGameCakeManager = new MiniGameCakeManager();
+	miniGameContainer.addChild(miniGameCakeManager);
+	// Initialize mini-game button
+	var miniGameButton = new MiniGameButton();
+	miniGameButton.x = 2048 / 2 - 150;
+	miniGameButton.y = 2732 / 2 - 200;
+	foregroundContainer.addChild(miniGameButton);
+	// Set up game loop
+	LK.onUpdate(gameLoop);
 }
 // Call the function to initialize game variables
-initializeGameVariables();
\ No newline at end of file
+initializeGameVariables();
+// Game loop
+function gameLoop(dt) {
+	// Update the cakes per second counter
+	cakesPerSecondCounter += dt;
+	if (cakesPerSecondCounter >= 1) {
+		cakesPerSecondCounter = 0;
+		cakes += cakesPerSecond;
+		updateCakeCounter();
+	}
+	// Only update main game animations if not in mini-game mode
+	if (!isMiniGameMode) {
+		// Update animations
+		updateAnimations(dt);
+	} else {
+		// Update mini-game
+		miniGameChef.update();
+		miniGameCakeManager.update(miniGameChef);
+	}
+}
+self.updateUpgradeText = function () {
+	priceText.setText('$' + self.price); // Update the price text to reflect the current cost
+};
\ No newline at end of file