/**** 
* Classes
****/ 
// BasicFlower class
var BasicFlower = Container.expand(function () {
	var self = Container.call(this);
	var budGraphics = self.attachAsset('Bud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var flowerGraphics = self.attachAsset('BasicFlower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.pollenPattern = 'cross';
	// Add breathing animation to the flower
	self.update = function () {
		// Calculate scale factor based on sine wave for breathing effect
		var scaleFactor = 1 + Math.sin(LK.ticks * 0.1) * 0.05;
		flowerGraphics.scale.x = scaleFactor;
		flowerGraphics.scale.y = scaleFactor;
		// Add consistent rotation to the breathing animation
		flowerGraphics.rotation = Math.sin(LK.ticks * 0.1) * 0.05;
	};
});
// Bud class
var Bud = Container.expand(function () {
	var self = Container.call(this);
	self.isBloomed = false; // Initialize isBloomed state to false
	var budGraphics = self.attachAsset('Bud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add a quick, pronounced jiggle animation to buds
	self.update = function () {
		var delay = Math.floor(Math.random() * 240 + 240);
		// Define a counter for the number of jiggles
		var jiggleCount = 0;
		// If the current tick is a multiple of the delay
		if (LK.ticks % delay == 0) {
			// Increment the jiggle count
			jiggleCount++;
			// If the jiggle count is less than or equal to 2
			if (jiggleCount <= 2) {
				// Jiggle the bud quickly in one direction and then the other
				self.rotation += 0.1;
				LK.setTimeout(function () {
					self.rotation -= 0.1;
				}, 200);
			} else {
				jiggleCount = 0;
				self.rotation = 0;
			}
		}
	};
});
// FlowerManager class to control flower stages and pollination
var FlowerManager = Container.expand(function () {
	var self = Container.call(this);
	self.init = function (garden) {
		// Place flowers/buds in grid
		for (var i = 0; i < garden.rows; i++) {
			for (var j = 0; j < garden.cols; j++) {
				var xPos = j * garden.cellSize + garden.cellSize / 2;
				var yPos = i * garden.cellSize + garden.cellSize / 2;
				if (i === Math.floor(garden.rows / 2) && j === Math.floor(garden.cols / 2)) {
					var flower = new BasicFlower();
					flower.x = xPos;
					flower.y = yPos;
					flower.isBud = false;
					flower.isFlower = true;
					garden.grid[i][j] = flower;
					garden.addChild(flower);
				} else {
					var bud = new Bud();
					bud.x = xPos;
					bud.y = yPos;
					bud.isBud = true;
					bud.isFlower = false;
					garden.grid[i][j] = bud;
					garden.addChild(bud);
				}
			}
		}
	};
	self.handleTouch = function (x, y, obj, garden) {
		var localPos = garden.toLocal(obj.global);
		var gridX = Math.floor(localPos.x / garden.cellSize);
		var gridY = Math.floor(localPos.y / garden.cellSize);
		if (gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) {
			var touchedFlower = garden.grid[gridY][gridX];
			if (touchedFlower && touchedFlower.isFlower) {
				// Handle flower touch
				// Convert flower position to global space for particles
				var globalPos = garden.toGlobal({
					x: touchedFlower.x,
					y: touchedFlower.y
				});
				// Destroy all buds underneath the touched flower
				garden.removeChild(touchedFlower);
				garden.grid[gridY][gridX] = null;
				// Add a new Bud with a growing animation
				var newBud = new Bud();
				newBud.x = touchedFlower.x;
				newBud.y = touchedFlower.y;
				newBud.isBud = true;
				newBud.isFlower = false;
				newBud.scale.set(0.1, 0.1); // Start small for growth animation
				garden.addChild(newBud);
				garden.grid[gridY][gridX] = newBud;
				// Animate growth to full size
				var growthDuration = 60; // Duration in frames
				var growthStep = 1 / growthDuration;
				var currentStep = 0;
				newBud.update = function () {
					if (currentStep < growthDuration) {
						this.scale.x = Math.min(1, this.scale.x + growthStep);
						this.scale.y = Math.min(1, this.scale.y + growthStep);
						currentStep++;
					} else {
						// Resume jiggle animation after growth
						this.update = function () {
							var _this = this;
							var delay = Math.floor(Math.random() * 240 + 240);
							var jiggleCount = 0;
							if (LK.ticks % delay == 0) {
								jiggleCount++;
								if (jiggleCount <= 2) {
									this.rotation += 0.1;
									LK.setTimeout(function () {
										_this.rotation -= 0.1;
									}, 200);
								} else {
									jiggleCount = 0;
									this.rotation = 0;
								}
							}
						};
					}
				};
				// Convert adjacent buds
				var adjacentPositions = [{
					x: gridY - 1,
					y: gridX
				},
				// Up
				{
					x: gridY + 1,
					y: gridX
				},
				// Down
				{
					x: gridY,
					y: gridX - 1
				},
				// Left
				{
					x: gridY,
					y: gridX + 1
				} // Right
				];
				adjacentPositions.forEach(function (pos) {
					if (garden.grid[pos.x] && garden.grid[pos.x][pos.y]) {
						var adjacentFlower = garden.grid[pos.x][pos.y];
						if (adjacentFlower.isBud) {
							// Add a new flower
							var newFlower = new BasicFlower();
							newFlower.x = adjacentFlower.x;
							newFlower.y = adjacentFlower.y;
							newFlower.isBud = false;
							newFlower.isFlower = true;
							newFlower.scale.set(0.3, 0.3); // Start a little bigger for growth animation
							// Animate growth to full size
							var growthDuration = 40; // Duration in frames, faster growth
							var growthStep = 1 / growthDuration;
							var currentStep = 0;
							newFlower.update = function () {
								if (currentStep < growthDuration) {
									this.scale.x = Math.min(1, this.scale.x + growthStep);
									this.scale.y = Math.min(1, this.scale.y + growthStep);
									currentStep++;
								} else {
									// Remove the bud from the garden after growth
									garden.removeChild(adjacentFlower);
									garden.grid[pos.x][pos.y] = newFlower; // Register the new flower in the grid
									// Start breathing animation after growth
									this.update = function () {
										var scaleFactor = 1 + Math.sin(LK.ticks * 0.1) * 0.05;
										this.scale.x = scaleFactor;
										this.scale.y = scaleFactor;
										this.rotation = Math.sin(LK.ticks * 0.1) * 0.05; // Add consistent rotation
									};
								}
							};
							garden.addChild(newFlower);
							adjacentFlower.isBloomed = true; // Set isBloomed to true
							garden.grid[pos.x][pos.y] = newFlower;
						}
					}
				});
			}
		}
	};
});
//<Assets used in the game will automatically appear here>
// Garden class to manage the grid of soil
var Garden = Container.expand(function () {
	var self = Container.call(this);
	self.grid = [];
	self.rows = 9;
	self.cols = 9;
	self.cellSize = 200; // Size of each grid cell
	self.init = function () {
		// Center the grid on screen
		self.x = (2048 - self.cols * self.cellSize) / 2;
		self.y = (2732 - self.rows * self.cellSize) / 2 + 2732 * 0.12 - 400;
		// Initialize grid with null values
		for (var i = 0; i < self.rows; i++) {
			self.grid[i] = [];
			for (var j = 0; j < self.cols; j++) {
				self.grid[i][j] = null; // Will store flower/bud references
			}
		}
	};
});
// GardenBackground class
var GardenBackground = Container.expand(function () {
	var self = Container.call(this);
	var gardenBackground = LK.getAsset('GardenBackground', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.02,
		scaleY: 1.02,
		x: 2048 / 2,
		y: 2732 / 2
	});
	self.addChild(gardenBackground);
});
// Goal display class
var GoalDisplay = Container.expand(function () {
	var self = Container.call(this);
	self.goals = [];
	self.init = function (goals) {
		self.goals = goals;
		for (var i = 0; i < self.goals.length; i++) {
			var goalText = new Text2(self.goals[i].icon + ' ' + self.goals[i].collected + '/' + self.goals[i].needed, {
				size: 100,
				fill: 0xFFFFFF
			});
			goalText.anchor.set(0.5, 0);
			goalText.y = i * 150;
			self.addChild(goalText);
		}
	};
});
// PollenParticle class
var PollenParticle = Container.expand(function () {
	var self = Container.call(this);
	var pollenGraphics = self.attachAsset('PollenSparkle', {
		anchorX: 0.5,
		anchorY: 0.5,
		scale: 0.5 // Start with a smaller scale
	});
	self.pattern = '';
	// Initialize with random rotation
	self.rotation = Math.random() * Math.PI * 2;
	// Initialize with slight random offset
	self.offset = {
		x: Math.random() * 10 - 5,
		y: Math.random() * 10 - 5
	};
	self.update = function () {
		if (self.pattern === 'sourceBurst') {
			var angle = Math.random() * Math.PI * 2;
			var speed = Math.random() * 5;
			self.x += Math.cos(angle) * speed + self.offset.x * 0.1;
			self.y += Math.sin(angle) * speed + self.offset.y * 0.1;
			self.rotation += 0.05;
		}
		self.alpha -= 0.05;
		if (self.alpha <= 0) {
			self.destroy();
		}
	};
});
// Level display class
var LevelDisplay = Text2.expand(function () {
	var self = Text2.call(this, 'Level 1', {
		size: 150,
		fill: 0xFFFFFF
	});
});
// Score display class
var ScoreDisplay = Text2.expand(function () {
	var self = Text2.call(this, '0', {
		size: 150,
		fill: 0xFFFFFF
	});
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000 //Init game with black background 
});

/**** 
* Game Code
****/ 
// Declare and initialize flowerManager in global scope
var flowerManager = new FlowerManager();
var titleScreen = new Container();
var background = LK.getAsset('titlebackground', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2
});
titleScreen.addChild(background);
var logo = LK.getAsset('logo', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2
});
titleScreen.addChild(logo);
var playButton = LK.getAsset('playButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2 + 200
});
titleScreen.addChild(playButton);
var tutorialButton = LK.getAsset('tutorialButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2 + 400
});
titleScreen.addChild(tutorialButton);
game.addChild(titleScreen);
playButton.down = function (x, y, obj) {
	game.removeChild(titleScreen);
	var gardenBackground = new GardenBackground();
	game.addChild(gardenBackground);
	// Initialize garden
	var garden = new Garden();
	garden.init();
	game.addChild(garden);
	var flowerManager = new FlowerManager();
	flowerManager.init(garden);
	game.down = function (x, y, obj) {
		flowerManager.handleTouch(x, y, obj, garden);
	};
	// Initialize score display
	var scoreDisplay = new ScoreDisplay();
	scoreDisplay.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreDisplay);
	// Initialize level display
	var levelDisplay = new LevelDisplay();
	levelDisplay.anchor.set(0.5, 1);
	LK.gui.bottom.addChild(levelDisplay);
	// Initialize goal display
	var goalDisplay = new GoalDisplay();
	goalDisplay.x = 2048 - 150;
	goalDisplay.y = 0;
	game.addChild(goalDisplay);
	goalDisplay.init([{
		icon: '🌼',
		collected: 0,
		needed: 10
	}, {
		icon: '🌸',
		collected: 0,
		needed: 5
	}, {
		icon: '🌺',
		collected: 0,
		needed: 3
	}]);
	// Initialize menu button
	var menuButton = LK.getAsset('menuButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 100 + 2048 * 0.01,
		y: 250 + 2732 * 0.04
	});
	menuButton.down = function (x, y, obj) {
		// Remove all game elements
		game.removeChildren();
		// Remove score, level and goal display from GUI
		LK.gui.top.removeChild(scoreDisplay);
		LK.gui.topRight.removeChild(levelDisplay);
		game.removeChild(goalDisplay);
		// Add the title screen back
		game.addChild(titleScreen);
	};
	game.addChild(menuButton);
};
tutorialButton.down = function (x, y, obj) {
	// Open tutorial
};
// Removed duplicate playPollenPatternAnimation method

===================================================================
--- original.js
+++ change.js
@@ -95,81 +95,11 @@
 				var globalPos = garden.toGlobal({
 					x: touchedFlower.x,
 					y: touchedFlower.y
 				});
-				// Play particle animation with global coordinates
-				game.playPollenPatternAnimation('sourceBurst', {
-					x: globalPos.x,
-					y: globalPos.y
-				});
-				// Check for adjacent BasicFlowers
-				var adjacentFlowers = [];
-				var directions = [{
-					x: -1,
-					y: 0
-				},
-				// Up
-				{
-					x: 1,
-					y: 0
-				},
-				// Down
-				{
-					x: 0,
-					y: -1
-				},
-				// Left
-				{
-					x: 0,
-					y: 1
-				},
-				// Right
-				// Diagonal Up-Left
-				{
-					x: -1,
-					y: -1
-				},
-				// Diagonal Up-Right
-				{
-					x: 1,
-					y: -1
-				},
-				// Diagonal Down-Left
-				{
-					x: -1,
-					y: 1
-				},
-				// Diagonal Down-Right
-				{
-					x: 1,
-					y: 1
-				}];
-				directions.forEach(function (dir) {
-					var adjX = gridX + dir.x;
-					var adjY = gridY + dir.y;
-					if (adjX >= 0 && adjX < garden.cols && adjY >= 0 && adjY < garden.rows) {
-						var adjacentFlower = garden.grid[adjY][adjX];
-						if (adjacentFlower && adjacentFlower.isFlower) {
-							adjacentFlowers.push(adjacentFlower);
-						}
-					}
-				});
-				// If three or more adjacent BasicFlowers are found, destroy them
-				if (adjacentFlowers.length >= 2) {
-					adjacentFlowers.push(touchedFlower); // Include the touched flower
-					var delay = 0;
-					adjacentFlowers.reverse().forEach(function (flower, index) {
-						LK.setTimeout(function () {
-							garden.removeChild(flower);
-							garden.grid[gridY][gridX] = null;
-						}, delay);
-						delay += 200; // Add delay between each destruction
-					});
-				} else {
-					// Destroy the touched flower if no pattern is completed
-					garden.removeChild(touchedFlower);
-					garden.grid[gridY][gridX] = null;
-				}
+				// Destroy all buds underneath the touched flower
+				garden.removeChild(touchedFlower);
+				garden.grid[gridY][gridX] = null;
 				// Add a new Bud with a growing animation
 				var newBud = new Bud();
 				newBud.x = touchedFlower.x;
 				newBud.y = touchedFlower.y;
@@ -379,45 +309,8 @@
 * Game Code
 ****/ 
 // Declare and initialize flowerManager in global scope
 var flowerManager = new FlowerManager();
-// Method to play pollen pattern animation
-game.playPollenPatternAnimation = function (pattern, position) {
-	switch (pattern) {
-		case 'sourceBurst':
-			for (var i = 0; i < 10; i++) {
-				var pollenParticle = new PollenParticle();
-				// Convert position to local space for the particle
-				var localPos = game.toLocal(position);
-				pollenParticle.x = localPos.x;
-				pollenParticle.y = localPos.y;
-				pollenParticle.pattern = pattern;
-				pollenParticle.alpha = 1;
-				// Update particle behavior
-				pollenParticle.update = function () {
-					if (this.pattern === 'sourceBurst') {
-						var angle = Math.random() * Math.PI * 2;
-						var speed = Math.random() * 5;
-						this.x += Math.cos(angle) * speed + this.offset.x * 0.1;
-						this.y += Math.sin(angle) * speed + this.offset.y * 0.1;
-						// Add rotation for more organic movement
-						this.rotation += Math.random() * 0.1;
-						// Add slight scale variation
-						this.scale.x = this.scale.y = 1 + Math.sin(LK.ticks * 0.1) * 0.2;
-					}
-					this.alpha -= 0.05;
-					if (this.alpha <= 0) {
-						this.destroy();
-					}
-				};
-				game.addChild(pollenParticle);
-			}
-			break;
-		case 'cross':
-			// Similar updates for cross pattern...
-			break;
-	}
-};
 var titleScreen = new Container();
 var background = LK.getAsset('titlebackground', {
 	anchorX: 0.5,
 	anchorY: 0.5,