/**** 
* 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 slight random rotation to the breathing animation
		flowerGraphics.rotation = Math.sin(LK.ticks * 0.1) * 0.05 * Math.random();
	};
});
// Bud class
var Bud = Container.expand(function () {
	var self = Container.call(this);
	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
				});
				// Play particle animation with global coordinates
				game.playPollenPatternAnimation('sourceBurst', {
					x: globalPos.x,
					y: globalPos.y
				});
				// 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) {
							var newFlower = new BasicFlower();
							newFlower.x = adjacentFlower.x;
							newFlower.y = adjacentFlower.y;
							newFlower.isBud = false;
							newFlower.isFlower = true;
							garden.addChild(newFlower);
							garden.removeChild(adjacentFlower);
							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 = '';
	self.flower = null; // Store reference to source flower
	// 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();
// 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,
	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,14 +95,12 @@
 					x: touchedFlower.x,
 					y: touchedFlower.y
 				});
 				// Play particle animation with global coordinates
-				if (touchedFlower) {
-					game.playPollenPatternAnimation('sourceBurst', {
-						x: globalPos.x,
-						y: globalPos.y
-					});
-				}
+				game.playPollenPatternAnimation('sourceBurst', {
+					x: globalPos.x,
+					y: globalPos.y
+				});
 				// Convert adjacent buds
 				var adjacentPositions = [{
 					x: gridY - 1,
 					y: gridX
@@ -201,8 +199,9 @@
 		anchorY: 0.5,
 		scale: 0.5 // Start with a smaller scale
 	});
 	self.pattern = '';
+	self.flower = null; // Store reference to source flower
 	// Initialize with random rotation
 	self.rotation = Math.random() * Math.PI * 2;
 	// Initialize with slight random offset
 	self.offset = {
@@ -251,21 +250,41 @@
 // Declare and initialize flowerManager in global scope
 var flowerManager = new FlowerManager();
 // Method to play pollen pattern animation
 game.playPollenPatternAnimation = function (pattern, position) {
-	var particle = new PollenParticle();
-	particle.x = position.x;
-	particle.y = position.y;
-	// Try different containers:
-	// Option 1: Add to garden (same as flowers)
-	//garden.addChild(particle);
-	// Option 2: Add to top GUI layer
-	// LK.gui.top.addChild(particle);
-	// Option 3: Add as topmost child of game
-	// game.addChildAt(particle, game.children.length);
-	// Option 4: Add to the same parent as the flowers
-	if (touchedFlower && touchedFlower.parent) {
-		touchedFlower.parent.addChild(particle);
+	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', {