/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var BasicFlower = Container.expand(function (color) {
	var self = Container.call(this);
	// Store flower color
	self.color = color || 'red'; // Default to red if no color specified
	// Map color to asset name
	var assetMap = {
		'red': 'RedFlower',
		'blue': 'BlueFlower',
		'yellow': 'YellowFlower'
	};
	// Attach bud asset first
	var budGraphics = self.attachAsset('Bud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Use correct asset based on color
	var flowerGraphics = self.attachAsset(assetMap[self.color], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.hasActivePollen = false;
	self.fairyParticles = [];
	self.FAIRY_COUNT = 3;
	self.update = function () {
		var scaleFactor = 1 + Math.sin(LK.ticks * 0.1) * 0.05;
		flowerGraphics.scale.x = scaleFactor;
		flowerGraphics.scale.y = scaleFactor;
		flowerGraphics.rotation = Math.sin(LK.ticks * 0.1) * 0.05;
	};
	self.bloom = function () {
		// Scale animation
		self.scale.set(0.3, 0.3);
		tween(self.scale, {
			x: 1,
			y: 1
		}, {
			duration: 1000,
			onFinish: function onFinish() {
				// Set active pollen state before checking matches
				self.hasActivePollen = true;
				self.pollenCollected = false;
				// Find position in grid
				var foundGridPos = false;
				var gridX = 0;
				var gridY = 0;
				for (var y = 0; y < garden.rows; y++) {
					for (var x = 0; x < garden.cols; x++) {
						if (garden.grid[y][x] === self) {
							gridX = x;
							gridY = y;
							foundGridPos = true;
							break;
						}
					}
					if (foundGridPos) {
						break;
					}
				}
				// Check for matches after bloom completes
				if (foundGridPos && game.flowerMatcher) {
					LK.setTimeout(function () {
						game.flowerMatcher.checkForMatches(garden, gridX, gridY);
					}, 100); // Short delay to ensure animation completes
				}
			}
		});
		// Create initial burst particles
		self.createPollenBurst(self.x, self.y);
		self.removeFairyParticles = function () {
			self.fairyParticles.forEach(function (fairy) {
				self.removeChild(fairy);
			});
			self.fairyParticles = [];
		};
	};
	self.createPollenBurst = function (x, y) {
		for (var i = 0; i < 12; i++) {
			var particle = new PollenParticle().init('burst');
			var angle = i / 12 * Math.PI * 2;
			particle.x = x;
			particle.y = y;
			particle.vx = Math.cos(angle) * 3;
			particle.vy = Math.sin(angle) * 3;
			if (self.parent) {
				self.parent.addChild(particle);
			}
		}
	};
	// Initialize pollen status
	self.pollenCollected = true; // Set to true so pollen can't be collected
});
var Bee = Container.expand(function () {
	var self = Container.call(this);
	self.currentColor = null; // Add this back
	// Movement properties 
	var beeSprite = self.attachAsset('Bee', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Movement properties
	self.targetX = self.x;
	self.targetY = self.y;
	self.moveSpeed = 0.1; // Adjust this for faster/slower following
	self.isMoving = false;
	// New pollen properties
	self.maxPollen = 14; // Exactly enough for 2 buds (2 * 7 = 14)
	self.currentPollen = 0; // Current amount being carried
	self.pollenTypes = []; // Array to track different pollen colors
	// Format: [{color: 'red', amount: 30}, ...]
	// Add trail property
	self.pollenTrail = new PollenTrail();
	game.addChild(self.pollenTrail); // Add to game so it renders behind bee
	// Pollen collection method
	self.collectPollen = function (flower) {
		if (self.currentPollen < self.maxPollen && flower.isSourceFlower) {
			if (self.currentPollen >= self.maxPollen) {
				return; // Don't collect if we're at max
			}
			var collectAmount = Math.min(14, self.maxPollen - self.currentPollen);
			// Add to pollen types first
			var existingType = self.pollenTypes.find(function (p) {
				return p.color === flower.color;
			});
			if (existingType) {
				existingType.amount += collectAmount;
			} else {
				self.pollenTypes.push({
					color: flower.color,
					amount: collectAmount
				});
			}
			// Restart trail with current color
			if (self.pollenTrail) {
				self.pollenTrail.active = false; // Force restart
				self.pollenTrail.startTrail(self.x, self.y, garden, self);
			}
			// Set currentPollen to match total of all types
			self.currentPollen = self.pollenTypes.reduce(function (total, type) {
				return total + type.amount;
			}, 0);
			self.currentColor = flower.color; // Add this back
			self.pollenTrail.currentColor = flower.color;
			if (!flower.isSourceFlower) {
				flower.pollenCollected = true;
				flower.hasActivePollen = false;
				flower.removeFairyParticles();
			} else {
				// Source flowers reset immediately
				flower.hasActivePollen = true;
				flower.pollenCollected = false;
			}
			// Removed bee UI update call
			// Removed match checking from collectPollen method
		}
	};
	self.checkFlowerCollision = function () {
		// Convert bee position to garden's local space
		var localPos = garden.toLocal({
			x: self.x,
			y: self.y
		}, game);
		// Check source flowers first
		if (garden.sourceFlowers) {
			garden.sourceFlowers.children.forEach(function (flower) {
				var dx = localPos.x - flower.x;
				var dy = localPos.y - flower.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < garden.cellSize / 2) {
					self.collectPollen(flower);
				}
			});
		}
		// Calculate grid position
		var gridX = Math.floor(localPos.x / garden.cellSize);
		var gridY = Math.floor(localPos.y / garden.cellSize);
		// Check if position is within grid bounds
		if (gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) {
			var gridItem = garden.grid[gridY][gridX];
			if (gridItem) {
				if (gridItem.isFlower && gridItem.hasActivePollen && gridItem.scale.x >= 1 && gridItem.color === self.currentColor) {
					// Collect pollen from flower
					self.collectPollen(gridItem);
				} else if (gridItem && gridItem.isBud && self.currentPollen > 0) {
					if (gridItem.isBeingPollinated) {
						return;
					}
					gridItem.isBeingPollinated = true;
					var pollenColor = self.usePollen(gridItem);
					if (!pollenColor) {
						gridItem.isBeingPollinated = false;
						return;
					}
					// Double-check the bud is still there
					if (garden.grid[gridY][gridX] === gridItem && gridItem.isBud) {
						// Force remove the bud and clear grid position
						garden.removeChild(gridItem);
						garden.grid[gridY][gridX] = null;
						gridItem.destroy(); // Fully destroy the bud
						// Only create flower if position is clear
						if (!garden.grid[gridY][gridX]) {
							var newFlower = new BasicFlower(pollenColor);
							newFlower.x = gridItem.x;
							newFlower.y = gridItem.y;
							newFlower.isFlower = true;
							garden.grid[gridY][gridX] = newFlower;
							garden.addChild(newFlower);
							newFlower.bloom();
						}
					} else {
						gridItem.isBeingPollinated = false;
					}
				}
			}
		}
	};
	self.update = function () {
		if (self.isMoving) {
			// Smooth movement towards target
			self.x += (self.targetX - self.x) * self.moveSpeed;
			self.y += (self.targetY - self.y) * self.moveSpeed;
			// Calculate rotation based on movement direction
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var angle = Math.atan2(dy, dx);
			self.rotation = angle + Math.PI / 2;
			// Update trail when carrying pollen
			if (self.currentPollen > 0) {
				// Make sure trail starts if not already active
				if (!self.pollenTrail.active) {
					self.pollenTrail.startTrail(self.x, self.y, garden);
				}
				self.pollenTrail.updateTrail(self.x, self.y);
			}
			// Add collision check
			self.checkFlowerCollision();
		}
	};
	// Pollen usage method
	self.usePollen = function (bud) {
		// Add debug logs
		var pollenUsed = 7;
		if (self.currentPollen > 0 && self.pollenTypes.length > 0) {
			// If we have less than pollenUsed, use remaining pollen
			if (self.currentPollen < pollenUsed) {
				pollenUsed = self.currentPollen;
			}
			// Reduce pollen instead of zeroing it
			self.currentPollen -= pollenUsed;
			// Update pollen types properly
			var pType = self.pollenTypes[0];
			var color = pType.color; // New line to store color
			pType.amount -= pollenUsed;
			if (self.currentPollen <= 0) {
				self.pollenTypes = []; // Clear all pollen types when empty
			}
			// Removed bee UI update call
			// Only clear type if it's empty
			if (pType.amount <= 0) {
				self.pollenTypes.shift();
			}
			// Only end trail if we're actually out of pollen
			if (self.currentPollen <= 0 || self.pollenTypes.length === 0) {
				self.pollenTrail.active = false;
				self.pollenTrail.points = [];
			}
			return color; // Updated to return color
		}
		return null;
	};
	return self;
});
// Bud class
var Bud = Container.expand(function () {
	var self = Container.call(this);
	var budGraphics = self.attachAsset('Bud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Timer properties
	self.bloomTimer = 5 * 60; // 5 seconds (assuming 60fps)
	self.isBud = true;
	self.isFlower = false;
	self.isBeingReplaced = false; // Add this flag
	// Update now handles timer and auto-bloom
	self.update = function () {
		// Basic animation
		self.rotation = Math.sin(LK.ticks * 0.05) * 0.1;
	};
	self.autoBloom = function () {
		if (!self.isBud || self.isBeingReplaced) {
			return; // Prevent double-blooming or if already being replaced
		}
		self.isBeingReplaced = true;
		// Get garden reference from parent
		var garden = self.parent;
		if (!garden) {
			return;
		}
		// Get grid position directly from garden
		for (var gridY = 0; gridY < garden.rows; gridY++) {
			for (var gridX = 0; gridX < garden.cols; gridX++) {
				if (garden.grid[gridY][gridX] === self) {
					// Create random color flower
					var flowerColors = ['red', 'blue', 'yellow'];
					var randomColor = flowerColors[Math.floor(Math.random() * flowerColors.length)];
					var newFlower = new BasicFlower(randomColor);
					newFlower.x = self.x;
					newFlower.y = self.y;
					newFlower.isFlower = true;
					newFlower.hasActivePollen = false;
					// Update grid
					garden.removeChild(self);
					garden.grid[gridY][gridX] = newFlower;
					garden.addChild(newFlower);
					newFlower.bloom();
					return;
				}
			}
		}
	};
	return self;
});
// Add BudSpawner to handle progressive difficulty
var BudSpawner = Container.expand(function () {
	var self = Container.call(this);
	self.patterns = {
		single: [[[0, 0]]],
		pairs: [[[0, 0], [0, 1]],
		// horizontal
		[[0, 0], [1, 0]],
		// vertical
		[[0, 0], [1, 1]] // diagonal
		],
		triples: [[[0, 0], [0, 1], [0, 2]],
		// horizontal
		[[0, 0], [1, 0], [2, 0]],
		// vertical
		[[0, 0], [1, 1], [2, 2]],
		// diagonal
		[[0, 0], [0, 1], [1, 0]] // L shape
		]
	};
	self.warningTime = 180; // 3 seconds at 60fps
	self.currentPattern = null;
	self.warningSprites = [];
	self.nextSpawnPosition = null;
	self.createWarning = function (x, y) {
		var warning = new Container();
		var crack = warning.attachAsset('Crack', {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0
		});
		warning.x = x;
		warning.y = y;
		warning.scale.set(0);
		// Create the growing crack animation
		tween(warning.scale, {
			x: 1,
			y: 1
		}, {
			duration: 1000,
			ease: 'elasticOut'
		});
		tween(crack, {
			alpha: 0.8
		}, {
			duration: 500
		});
		// Add rotation animation
		warning.update = function () {
			warning.rotation = Math.sin(LK.ticks * 0.03) * 0.1;
		};
		self.garden.addChild(warning);
		return warning;
	};
	self.updateWarningEffects = function () {
		var timeProgress = (180 - self.warningTime) / 180; // 0 to 1
		var intensity = Math.sin(timeProgress * Math.PI * 4) * 0.5 + 0.5; // Pulsing effect
		self.warningSprites.forEach(function (sprite) {
			// Increase glow and intensity as spawn time approaches
			sprite.children[0].alpha = 0.3 + intensity * 0.7;
			sprite.children[0].scale.set(0.8 + intensity * 0.4);
			// Add subtle shake when close to spawning
			if (self.warningTime < 60) {
				// Last second
				sprite.x += (Math.random() - 0.5) * 2;
				sprite.y += (Math.random() - 0.5) * 2;
			}
		});
	};
	self.garden = null;
	self.gameTime = 0;
	self.init = function (garden) {
		self.garden = garden;
		self.gameTime = 0;
		self.firstBloom = false;
		// Just set the first bloom timer
		self.nextBloomTime = 90; // 1.5 seconds for first bloom
	};
	self.findEmptySpot = function () {
		var validSpots = [];
		// Match flower removal coordinate system [gridY][gridX]
		for (var gridY = 0; gridY < self.garden.rows; gridY++) {
			for (var gridX = 0; gridX < self.garden.cols; gridX++) {
				if (!self.garden.grid[gridY][gridX]) {
					validSpots.push({
						x: gridX,
						y: gridY
					});
				}
			}
		}
		if (validSpots.length > 0) {
			return validSpots[Math.floor(Math.random() * validSpots.length)];
		}
		return null;
	};
	self.selectSpawnPosition = function () {
		// Count empty spaces
		var emptySpaces = 0;
		var emptyPositions = [];
		for (var row = 0; row < self.garden.rows; row++) {
			for (var col = 0; col < self.garden.cols; col++) {
				if (self.garden.grid[row][col] === null) {
					emptySpaces++;
					emptyPositions.push({
						row: row,
						col: col
					});
				}
			}
		}
		// No empty spaces
		if (emptySpaces === 0) {
			return null;
		}
		// Select pattern size based on empty spaces
		var patternPool;
		if (emptySpaces >= 3) {
			patternPool = Math.random() < 0.7 ? self.patterns.triples : self.patterns.pairs;
		} else if (emptySpaces >= 2) {
			patternPool = Math.random() < 0.7 ? self.patterns.pairs : self.patterns.single;
		} else {
			patternPool = self.patterns.single;
		}
		// Find valid positions for selected pattern pool
		var validPositions = [];
		for (var _i = 0, _emptyPositions = emptyPositions; _i < _emptyPositions.length; _i++) {
			var _emptyPositions$_i = _emptyPositions[_i],
				row = _emptyPositions$_i.row,
				col = _emptyPositions$_i.col;
			var _iterator = _createForOfIteratorHelper6(patternPool),
				_step;
			try {
				patternCheck: for (_iterator.s(); !(_step = _iterator.n()).done;) {
					var pattern = _step.value;
					// Check if pattern fits at this position
					var _iterator2 = _createForOfIteratorHelper6(pattern),
						_step2;
					try {
						for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
							var _step2$value = _slicedToArray7(_step2.value, 2),
								drow = _step2$value[0],
								dcol = _step2$value[1];
							var nrow = row + drow;
							var ncol = col + dcol;
							if (nrow >= self.garden.rows || ncol >= self.garden.cols || self.garden.grid[nrow][ncol] !== null) {
								continue patternCheck;
							}
						}
					} catch (err) {
						_iterator2.e(err);
					} finally {
						_iterator2.f();
					}
					validPositions.push({
						row: row,
						col: col,
						pattern: pattern
					});
				}
			} catch (err) {
				_iterator.e(err);
			} finally {
				_iterator.f();
			}
		}
		// If no patterns fit, fall back to single bud
		if (validPositions.length === 0 && emptySpaces > 0) {
			var randomEmpty = emptyPositions[Math.floor(Math.random() * emptyPositions.length)];
			return {
				row: randomEmpty.row,
				col: randomEmpty.col,
				pattern: self.patterns.single[0]
			};
		}
		return validPositions.length > 0 ? validPositions[Math.floor(Math.random() * validPositions.length)] : null;
	};
	self.getSpawnRate = function () {
		// Keep original timing logic
		return 16; // Spawn every frame for immediate filling
	};
	self.update = function () {
		// Initialize timing trackers
		if (!self.lastSpawnTime) {
			self.lastSpawnTime = LK.ticks;
			self.isFirstSpawn = true;
		}
		// Quick first spawn (2 seconds), then 5 seconds for subsequent spawns
		if (!self.currentPattern) {
			var requiredDelay = self.isFirstSpawn ? 120 : 240; // 2 seconds vs 4 seconds 
			if (LK.ticks - self.lastSpawnTime < requiredDelay) {
				return;
			}
			// Update spawn time and first spawn flag
			self.lastSpawnTime = LK.ticks;
			self.isFirstSpawn = false;
			// Select new spawn position and pattern
			var spawnInfo = self.selectSpawnPosition();
			if (spawnInfo && spawnInfo.row !== undefined && spawnInfo.col !== undefined) {
				self.currentPattern = spawnInfo.pattern;
				self.nextSpawnPosition = {
					row: parseInt(spawnInfo.row),
					col: parseInt(spawnInfo.col)
				};
				self.warningTime = 180; // Reset warning timer
				// Create warning indicators for pattern
				self.warningSprites = [];
				if (self.currentPattern) {
					var _iterator3 = _createForOfIteratorHelper4(self.currentPattern),
						_step3;
					try {
						for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
							var _step3$value = _slicedToArray5(_step3.value, 2),
								dy = _step3$value[0],
								dx = _step3$value[1];
							if (dx !== undefined && dy !== undefined) {
								var targetRow = self.nextSpawnPosition.row + dy;
								var targetCol = self.nextSpawnPosition.col + dx;
								var worldPos = self.garden.gridToWorld(targetCol, targetRow);
								var warning = self.createWarning(worldPos.x - 400 + self.garden.cellSize, worldPos.y - 400 - 50);
								self.warningSprites.push(warning);
							}
						}
					} catch (err) {
						_iterator3.e(err);
					} finally {
						_iterator3.f();
					}
				}
			}
		} else if (self.nextSpawnPosition && self.currentPattern) {
			self.warningTime--;
			self.updateWarningEffects();
			if (self.warningTime <= 0) {
				// Spawn animation
				self.warningSprites.forEach(function (sprite) {
					tween(sprite.scale, {
						x: 1,
						y: 1
					}, {
						duration: 300,
						onFinish: function onFinish() {
							tween(sprite, {
								alpha: 0
							}, {
								duration: 200,
								onFinish: function onFinish() {
									return sprite.destroy();
								}
							});
						}
					});
				});
				// Cache spawn position before clearing
				var spawnRow = self.nextSpawnPosition.row;
				var spawnCol = self.nextSpawnPosition.col;
				var pattern = self.currentPattern;
				// Clear state before spawning to prevent timing issues
				self.warningSprites = [];
				self.currentPattern = null;
				self.nextSpawnPosition = null;
				// Spawn buds with delay between each
				pattern.forEach(function (pos, index) {
					var _pos = _slicedToArray8(pos, 2),
						dy = _pos[0],
						dx = _pos[1];
					LK.setTimeout(function () {
						var targetRow = spawnRow + dy;
						var targetCol = spawnCol + dx;
						if (targetRow >= 0 && targetRow < self.garden.rows && targetCol >= 0 && targetCol < self.garden.cols && !self.garden.grid[targetRow][targetCol]) {
							var newBud = new Bud();
							var worldPos = self.garden.gridToWorld(targetCol, targetRow);
							newBud.x = worldPos.x - 400 + self.garden.cellSize;
							newBud.y = worldPos.y - 400 - 50;
							newBud.scale.set(0);
							self.garden.grid[targetRow][targetCol] = newBud;
							self.garden.addChild(newBud);
							tween(newBud.scale, {
								x: 1,
								y: 1
							}, {
								duration: 1000,
								ease: 'elasticOut',
								onFinish: function onFinish() {
									// Set delayed auto-bloom after scale completes 
									LK.setTimeout(function () {
										if (newBud && newBud.parent && newBud.isBud && !newBud.isBeingReplaced) {
											newBud.autoBloom();
										}
									}, index === 0 ? 180 : 300);
								}
							});
						}
					}, index * 200);
				});
			}
		}
	};
});
// Simplified FlowerManager - mainly for flower conversion and management
var FlowerManager = Container.expand(function () {
	var self = Container.call(this);
	// Convert a bud to a flower
	self.convertBudToFlower = function (bud, garden) {
		var gridPos = {
			x: Math.floor((bud.y - garden.y) / garden.cellSize),
			y: Math.floor((bud.x - garden.x) / garden.cellSize)
		};
		var newFlower = new BasicFlower();
		newFlower.x = bud.x;
		newFlower.y = bud.y;
		newFlower.isFlower = true;
		garden.removeChild(bud);
		garden.grid[gridPos.x][gridPos.y] = newFlower;
		garden.addChild(newFlower);
		// When a flower blooms:
		createPollenBurst(newFlower.x, newFlower.y);
		return newFlower;
	};
	// Empty touch handler as we're using the new trail system
	self.handleTouch = function () {};
});
var FlowerMatcher = Container.expand(function () {
	var self = Container.call(this);
	self.checkForMatches = function (garden, x, y) {
		var matches = self.findMatches(garden, x, y);
		if (matches.length >= 3) {
			self.clearMatches(garden, matches);
			return true;
		}
		return false;
	};
	self.findMatches = function (garden, startX, startY) {
		if (startY < 0 || startY >= garden.rows || startX < 0 || startX >= garden.cols) {
			return [];
		}
		var startFlower = garden.grid[startY][startX];
		if (!startFlower || !startFlower.isFlower) {
			return [];
		}
		var flowerColor = startFlower.color;
		var matches = [];
		var visited = {};
		var _checkFlower = function checkFlower(x, y) {
			if (x < 0 || x >= garden.cols || y < 0 || y >= garden.rows) {
				return;
			}
			var key = x + ',' + y;
			if (visited[key]) {
				return;
			}
			visited[key] = true;
			var flower = garden.grid[y][x];
			if (flower && flower.isFlower && !flower.isSourceFlower && flower.scale.x >= 1 && flower.color === flowerColor) {
				matches.push({
					x: x,
					y: y,
					flower: flower
				});
				_checkFlower(x + 1, y);
				_checkFlower(x - 1, y);
				_checkFlower(x, y + 1);
				_checkFlower(x, y - 1);
			}
		};
		_checkFlower(startX, startY);
		return matches.length >= 3 ? matches : [];
	};
	self.clearMatches = function (garden, matches) {
		matches.forEach(function (match) {
			var flower = match.flower;
			// Expand and pop animation
			tween(flower.scale, {
				x: 1.3,
				y: 1.3
			}, {
				duration: 500,
				onFinish: function onFinish() {
					// Check if flower is still in expected position
					if (garden.grid[match.y][match.x] === flower) {
						// Create petal burst after animation
						self.createPetalBurst(match.x, match.y, flower.color);
						garden.grid[match.y][match.x] = null;
						garden.removeChild(flower);
						// Removed new bud creation after clearing matches
					}
				}
			});
		});
	};
	self.createPetalBurst = function (x, y, color) {
		var colorTints = {
			'red': 0xFF0000,
			'blue': 0x0000FF,
			'yellow': 0xFFFF00,
			'purple': 0x800080,
			'orange': 0xFFA500,
			'green': 0x00FF00
		};
		var worldPos = garden.gridToWorld(x, y);
		for (var i = 0; i < 12; i++) {
			var particle = new PollenParticle().init('burst');
			var angle = i / 12 * Math.PI * 2;
			particle.x = worldPos.x;
			particle.y = worldPos.y;
			particle.vx = Math.cos(angle) * 8;
			particle.vy = Math.sin(angle) * 8;
			particle.scale.set(0.8);
			particle.tint = colorTints[color];
			game.addChild(particle);
		}
	};
	return self;
});
//<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);
	// Add new helper method for safe grid updates
	self.updateGridPosition = function (row, col, item) {
		if (row >= 0 && row < self.rows && col >= 0 && col < self.cols) {
			// First clear any existing item
			var existingItem = self.grid[row][col];
			if (existingItem && existingItem.parent) {
				existingItem.parent.removeChild(existingItem);
			}
			// Then set new item
			self.grid[row][col] = item;
			return true;
		}
		return false;
	};
	self.grid = [];
	self.rows = 8;
	self.cols = 8;
	self.cellSize = 210;
	self.init = function () {
		var _this = this;
		// Add source flowers
		this.sourceFlowers = new Container();
		this.addChild(this.sourceFlowers);
		// Calculate positions
		var centerX = this.cols * this.cellSize / 2;
		// Blue flower at bottom center
		var blueFlower = new SourceFlower('blue');
		blueFlower.x = centerX;
		blueFlower.y = self.rows * self.cellSize + self.cellSize * 1.5; // Move down one more row
		this.sourceFlowers.addChild(blueFlower);
		// Red flower under bottom left bud
		var redFlower = new SourceFlower('red');
		redFlower.x = self.cellSize / 2; // Align with first column's center
		redFlower.y = self.rows * self.cellSize + self.cellSize * 1.5; // Move down one more row
		this.sourceFlowers.addChild(redFlower);
		// Yellow flower under bottom right bud
		var yellowFlower = new SourceFlower('yellow');
		yellowFlower.x = self.cols * self.cellSize - self.cellSize / 2; // Align with last column's center
		yellowFlower.y = self.rows * self.cellSize + self.cellSize * 1.5; // Move down one more row
		this.sourceFlowers.addChild(yellowFlower);
		// 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 empty grid
		for (var i = 0; i < self.rows; i++) {
			self.grid[i] = [];
			for (var j = 0; j < self.cols; j++) {
				self.grid[i][j] = null;
			}
		}
	};
	// Helper method to convert grid position to world position
	self.gridToWorld = function (gridX, gridY) {
		if (typeof gridX !== 'number' || typeof gridY !== 'number') {
			console.log('Invalid grid coordinates:', gridX, gridY);
			return {
				x: self.x,
				y: self.y
			}; // Return default position if invalid
		}
		return {
			x: self.x + gridX * self.cellSize + self.cellSize / 2,
			y: self.y + gridY * self.cellSize + self.cellSize / 2
		};
	};
	// Helper method to convert world position to grid position
	self.worldToGrid = function (worldX, worldY) {
		var localX = worldX - self.x;
		var localY = worldY - self.y;
		return {
			x: Math.floor(localX / self.cellSize),
			y: Math.floor(localY / self.cellSize)
		};
	};
});
// GardenBackground class
var GardenBackground = Container.expand(function () {
	var self = Container.call(this);
	var gardenBackground = LK.getAsset('SpringBackground', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.02,
		scaleY: 1.02,
		x: 2048 / 2,
		y: 2732 / 2
	});
	self.addChild(gardenBackground);
});
var Hive = Container.expand(function () {
	var self = Container.call(this);
	var hiveSprite = self.attachAsset('Hive', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.storedPollen = {
		'red': 0,
		'blue': 0,
		'yellow': 0
	};
	// Add meter above hive
	self.pollenMeter = new PollenMeter();
	self.pollenMeter.y = -200;
	self.addChild(self.pollenMeter);
	// Collection method
	self.collectFromBee = function (bee) {
		if (bee.currentPollen > 0) {
			// Transfer each type of pollen
			bee.pollenTypes.forEach(function (type) {
				// Initialize hive's stored pollen for this color if needed
				if (!self.storedPollen) {
					self.storedPollen = {};
				}
				if (!self.storedPollen[type.color]) {
					self.storedPollen[type.color] = 0;
				}
				// Add to hive's storage
				self.storedPollen[type.color] += type.amount;
				// Removed hive UI update call
			});
			// Create particles spread across the hive's width
			var particleCount = 20;
			var hiveWidth = 300;
			for (var i = 0; i < particleCount; i++) {
				var particle = new PollenParticle().init('transfer');
				particle.x = -hiveWidth / 2 + Math.random() * hiveWidth;
				particle.y = -200;
				particle.vx = (Math.random() - 0.5) * 0.5;
				particle.vy = 1 + Math.random();
				particle.twinkleOffset = Math.random() * Math.PI * 2;
				particle.twinkleSpeed = 0.1 + Math.random() * 0.1;
				particle.scale.set(0.5);
				self.addChild(particle);
			}
			// Clear bee's pollen
			bee.currentPollen = 0;
			bee.pollenTypes = [];
			// Removed bee UI update call
			// End bee's trail
			bee.pollenTrail.active = false;
			bee.pollenTrail.points = [];
		}
	};
	return self;
});
var PollenMeter = Container.expand(function () {
	var self = Container.call(this);
	// Create background bar
	var background = LK.getAsset('marker', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1,
		scaleY: 0.1
	});
	self.addChild(background);
	// Create fill bar
	var fill = LK.getAsset('marker', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0,
		scaleY: 0.1
	});
	fill.tint = 0xFFFF00; // Yellow for pollen
	self.fillBar = fill;
	self.addChild(fill);
	// Update method to show current pollen
	self.updateMeter = function (current, max) {
		fill.scale.x = current / max;
	};
	return self;
});
// PollenParticle class
var PollenParticle = Container.expand(function () {
	var self = Container.call(this);
	// Particle properties
	self.velocity = {
		x: 0,
		y: 0
	};
	self.lifespan = 1; // Goes from 1 to 0
	self.decayRate = 0.02; // How fast the particle fades
	self.type = 'trail'; // Can be 'trail' or 'burst'
	// Create the visual element
	var assetMap = {
		'trail': 'PollenSparkle',
		'burst': 'Petal',
		'fairy': 'PollenSparkle',
		'transfer': 'PollenSparkle'
	};
	var pollenGraphics;
	// Initialize with random properties for more organic feel
	self.init = function (type) {
		self.type = type || 'trail';
		if (!pollenGraphics) {
			pollenGraphics = self.attachAsset(assetMap[self.type], {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
		// Set initial scale based on type
		if (self.type === 'trail') {
			self.scale.set(0.7 + Math.random() * 0.3); // Larger for trail
			self.decayRate = 0.03; // Faster decay for trail
			// Slight random velocity for trail movement
			self.velocity = {
				x: (Math.random() - 0.5) * 2,
				y: (Math.random() - 0.5) * 2
			};
		} else if (self.type === 'burst') {
			self.scale.set(0.5 + Math.random() * 0.3); // Smaller initial size for bursts
			self.decayRate = 0.01; // Slower decay for longer travel
			// Radial burst velocity
			var angle = Math.random() * Math.PI * 2;
			var speed = 3 + Math.random() * 5; // Increased speed for further travel
			self.velocity = {
				x: Math.cos(angle) * speed,
				y: Math.sin(angle) * speed
			};
		} else if (self.type === 'fairy') {
			self.lifespan = undefined; // Don't fade out
			self.startAngle = Math.random() * Math.PI * 2; // Random start position
			self.orbitRadius = 20 + Math.random() * 40; // Increase orbit radius variation
			self.orbitSpeed = 0.005 + Math.random() * 0.03; // Increase orbit speed variation
			self.update = function () {
				var time = LK.ticks * self.orbitSpeed;
				// Orbit motion
				self.x = Math.cos(time + self.startAngle) * self.orbitRadius;
				self.y = Math.sin(time + self.startAngle) * self.orbitRadius;
				// Add bobbing
				self.y += Math.sin(time * 2 + self.startAngle) * 10;
			};
		}
		// Random rotation speed
		self.rotationSpeed = (Math.random() - 0.5) * 0.2;
		// Random starting rotation
		self.rotation = Math.random() * Math.PI * 2;
		// Add random rotation speed for dynamic movement
		self.rotationSpeed = (Math.random() - 0.5) * 0.2;
		// Full opacity to start
		self.alpha = 1;
		if (self.type === 'transfer') {
			self.scale.set(0.5);
			self.alpha = 1;
			self.twinkleOffset = 0; // Initialize twinkle offset 
			self.twinkleSpeed = 0.1; // Initialize twinkle speed 
			self.update = function () {
				// Gentle drift down 
				self.x += self.vx;
				self.y += self.vy;
				// Individual twinkle effect 
				self.alpha = 0.6 + Math.sin(LK.ticks * self.twinkleSpeed + self.twinkleOffset) * 0.4;
				// Remove when below hive 
				if (self.y > 100) {
					self.destroy();
				}
			};
		}
		return self;
	};
	self.update = function () {
		// Update position based on velocity
		self.x += self.velocity.x;
		self.y += self.velocity.y;
		// Add rotation
		self.rotation += self.rotationSpeed;
		// Slow down velocity over time
		self.velocity.x *= 0.95;
		self.velocity.y *= 0.95;
		// Update lifespan and alpha
		self.lifespan -= self.decayRate;
		self.alpha = self.lifespan;
		// Scale slightly varies with life
		var scalePulse = 1 + Math.sin(LK.ticks * 0.2) * 0.1;
		pollenGraphics.scale.set(scalePulse * self.scale.x);
		// Remove when lifecycle complete
		if (self.lifespan <= 0) {
			self.destroy();
		}
	};
});
// First, let's add a PollenTrail class to handle the dragging mechanic
var PollenTrail = Container.expand(function () {
	var self = Container.call(this);
	self.points = [];
	self.active = false;
	self.currentGarden = null; // Store reference to garden
	self.MAX_SPEED = 15; // Adjust this value for proper feel
	self.startTrail = function (x, y, garden, bee) {
		self.active = true;
		self.points = [{
			x: x,
			y: y,
			time: Date.now()
		}];
		self.startTime = Date.now();
		self.trailStartTime = Date.now();
		self.currentGarden = garden;
		self.bee = bee; // Store bee reference
		self.lastPoint = {
			x: x,
			y: y
		}; // Initialize lastPoint
		// Force red on first particle to verify bee storage
		var particle = new PollenParticle().init('trail');
		particle.children[0].tint = 0xFF0000;
		particle.x = x;
		particle.y = y;
		game.addChild(particle);
	};
	self.updateTrail = function (x, y) {
		if (!self.active) {
			return;
		}
		// Enforce maximum speed
		var dx = x - self.lastPoint.x;
		var dy = y - self.lastPoint.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > self.MAX_SPEED) {
			var ratio = self.MAX_SPEED / distance;
			x = self.lastPoint.x + dx * ratio;
			y = self.lastPoint.y + dy * ratio;
		}
		self.points.push({
			x: x,
			y: y,
			time: Date.now()
		});
		self.lastPoint = {
			x: x,
			y: y
		};
		// Create particle effect along trail
		var particle = new PollenParticle().init('trail');
		if (self.bee && self.bee.pollenTypes && self.bee.pollenTypes[0]) {
			if (self.bee.pollenTypes[0].color === 'red') {
				particle.children[0].tint = 0xFF0000;
			} else if (self.bee.pollenTypes[0].color === 'blue') {
				particle.children[0].tint = 0x0000FF;
			} else if (self.bee.pollenTypes[0].color === 'yellow') {
				particle.children[0].tint = 0xFFFF00;
			}
		}
		particle.x = x;
		particle.y = y;
		game.addChild(particle);
	};
	// Add the burst effect function
	self.createPollenBurst = function (x, y) {
		for (var i = 0; i < 12; i++) {
			var particle = new PollenParticle().init('burst');
			var angle = i / 12 * Math.PI * 2;
			var distance = 30;
			particle.x = x + Math.cos(angle) * distance;
			particle.y = y + Math.sin(angle) * distance;
			// Give particles outward velocity
			particle.vx = Math.cos(angle) * 3;
			particle.vy = Math.sin(angle) * 3;
			game.addChild(particle);
		}
	};
	self.endTrail = function () {
		if (!self.active) {
			return;
		}
		var affectedBuds = [];
		var checkedPositions = {};
		self.points.forEach(function (point) {
			var localPos = self.currentGarden.toLocal({
				x: point.x,
				y: point.y
			}, game);
			var gridX = Math.floor(localPos.x / self.currentGarden.cellSize);
			var gridY = Math.floor(localPos.y / self.currentGarden.cellSize);
			var posKey = gridX + ',' + gridY;
			if (!checkedPositions[posKey] && gridX >= 0 && gridX < self.currentGarden.cols && gridY >= 0 && gridY < self.currentGarden.rows) {
				checkedPositions[posKey] = true;
				var gridItem = self.currentGarden.grid[gridY][gridX];
				// Verify it's a valid bud
				if (gridItem && gridItem.isBud === true && gridItem.isFlower === false) {
					affectedBuds.push({
						bud: gridItem,
						gridX: gridX,
						gridY: gridY
					});
				}
			}
		});
		if (affectedBuds.length >= 2) {
			affectedBuds.forEach(function (budInfo) {
				// IMPORTANT: Clear the grid position first
				self.currentGarden.grid[budInfo.gridY][budInfo.gridX] = null;
				// Remove the bud from display list
				self.currentGarden.removeChild(budInfo.bud);
				// Create new flower
				var newFlower = new BasicFlower();
				newFlower.x = budInfo.bud.x;
				newFlower.y = budInfo.bud.y;
				newFlower.isFlower = true;
				// Update grid position and add to display list
				self.currentGarden.grid[budInfo.gridY][budInfo.gridX] = newFlower;
				self.currentGarden.addChild(newFlower);
				// Start bloom animation
				newFlower.bloom();
			});
		}
		self.active = false;
		self.points = [];
	};
	self.update = function () {
		// Just update particles, no time checks
		// Update all children particles
		for (var i = self.children.length - 1; i >= 0; i--) {
			var particle = self.children[i];
			if (particle && particle.update) {
				particle.update();
			}
		}
	};
});
// Add ScoreManager to handle chain reactions and scoring
var ScoreManager = Container.expand(function () {
	var self = Container.call(this);
	self.currentScore = 0;
	self.currentChain = 0;
	self.chainMultiplier = 1;
	self.addToChain = function () {
		self.currentChain++;
		self.chainMultiplier = Math.min(1 + self.currentChain * 0.5, 5); // Cap at 5x
		self.addScore(100 * self.chainMultiplier);
	};
	self.resetChain = function () {
		self.currentChain = 0;
		self.chainMultiplier = 1;
	};
	self.addScore = function (points) {
		self.currentScore += Math.floor(points);
		// Update score display
		if (game.scoreDisplay) {
			game.scoreDisplay.text = self.currentScore.toString();
		}
	};
});
var SourceFlower = Container.expand(function (color) {
	var self = Container.call(this);
	// Store flower color
	self.color = color;
	self.isSourceFlower = true; // Flag to identify source flowers
	// Map color to asset name
	var assetMap = {
		'red': 'RedFlower',
		'blue': 'BlueFlower',
		'yellow': 'YellowFlower'
	};
	// Create flower sprite
	var flowerGraphics = self.attachAsset(assetMap[self.color], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Source flowers always have pollen
	self.hasActivePollen = true;
	self.fairyParticles = [];
	self.FAIRY_COUNT = 3;
	// Initialize fairy particles
	for (var i = 0; i < self.FAIRY_COUNT; i++) {
		var fairy = new PollenParticle().init('fairy');
		fairy.scale.set(0.3 + Math.random() * 0.2);
		fairy.x += (Math.random() - 0.5) * 60;
		fairy.y += (Math.random() - 0.5) * 60;
		fairy.rotation = Math.random() * Math.PI * 2;
		fairy.rotationSpeed = (Math.random() - 0.5) * 0.2;
		self.addChild(fairy);
		self.fairyParticles.push(fairy);
	}
	// Gentle animation
	self.update = function () {
		var scaleFactor = 1 + Math.sin(LK.ticks * 0.1) * 0.05;
		flowerGraphics.scale.x = scaleFactor;
		flowerGraphics.scale.y = scaleFactor;
		flowerGraphics.rotation = Math.sin(LK.ticks * 0.1) * 0.05;
		// Update fairy particles
		self.fairyParticles.forEach(function (fairy) {
			if (fairy && fairy.update) {
				fairy.update();
			}
		});
	};
	// Override collection behavior - source flowers regenerate pollen immediately
	self.pollenCollected = false;
	self.resetPollen = function () {
		self.hasActivePollen = true;
		self.pollenCollected = false;
	};
	self.collectPollen = function () {
		// Reset immediately to allow continuous collection
		self.hasActivePollen = true;
		self.pollenCollected = false;
	};
	return self;
});
// 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
function _slicedToArray8(r, e) {
	return _arrayWithHoles8(r) || _iterableToArrayLimit8(r, e) || _unsupportedIterableToArray8(r, e) || _nonIterableRest8();
}
function _nonIterableRest8() {
	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _unsupportedIterableToArray8(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray8(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray8(r, a) : void 0;
	}
}
function _arrayLikeToArray8(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
function _iterableToArrayLimit8(r, l) {
	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (null != t) {
		var e,
			n,
			i,
			u,
			a = [],
			f = !0,
			o = !1;
		try {
			if (i = (t = t.call(r)).next, 0 === l) {
				if (Object(t) !== t) {
					return;
				}
				f = !1;
			} else {
				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
					;
				}
			}
		} catch (r) {
			o = !0, n = r;
		} finally {
			try {
				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
					return;
				}
			} finally {
				if (o) {
					throw n;
				}
			}
		}
		return a;
	}
}
function _arrayWithHoles8(r) {
	if (Array.isArray(r)) {
		return r;
	}
}
function _slicedToArray7(r, e) {
	return _arrayWithHoles7(r) || _iterableToArrayLimit7(r, e) || _unsupportedIterableToArray7(r, e) || _nonIterableRest7();
}
function _nonIterableRest7() {
	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _iterableToArrayLimit7(r, l) {
	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (null != t) {
		var e,
			n,
			i,
			u,
			a = [],
			f = !0,
			o = !1;
		try {
			if (i = (t = t.call(r)).next, 0 === l) {
				if (Object(t) !== t) {
					return;
				}
				f = !1;
			} else {
				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
					;
				}
			}
		} catch (r) {
			o = !0, n = r;
		} finally {
			try {
				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
					return;
				}
			} finally {
				if (o) {
					throw n;
				}
			}
		}
		return a;
	}
}
function _arrayWithHoles7(r) {
	if (Array.isArray(r)) {
		return r;
	}
}
function _createForOfIteratorHelper6(r, e) {
	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (!t) {
		if (Array.isArray(r) || (t = _unsupportedIterableToArray7(r)) || e && r && "number" == typeof r.length) {
			t && (r = t);
			var _n6 = 0,
				F = function F() {};
			return {
				s: F,
				n: function n() {
					return _n6 >= r.length ? {
						done: !0
					} : {
						done: !1,
						value: r[_n6++]
					};
				},
				e: function e(r) {
					throw r;
				},
				f: F
			};
		}
		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	var o,
		a = !0,
		u = !1;
	return {
		s: function s() {
			t = t.call(r);
		},
		n: function n() {
			var r = t.next();
			return a = r.done, r;
		},
		e: function e(r) {
			u = !0, o = r;
		},
		f: function f() {
			try {
				a || null == t["return"] || t["return"]();
			} finally {
				if (u) {
					throw o;
				}
			}
		}
	};
}
function _unsupportedIterableToArray7(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray7(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray7(r, a) : void 0;
	}
}
function _arrayLikeToArray7(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
function _slicedToArray6(r, e) {
	return _arrayWithHoles6(r) || _iterableToArrayLimit6(r, e) || _unsupportedIterableToArray6(r, e) || _nonIterableRest6();
}
function _nonIterableRest6() {
	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _iterableToArrayLimit6(r, l) {
	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (null != t) {
		var e,
			n,
			i,
			u,
			a = [],
			f = !0,
			o = !1;
		try {
			if (i = (t = t.call(r)).next, 0 === l) {
				if (Object(t) !== t) {
					return;
				}
				f = !1;
			} else {
				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
					;
				}
			}
		} catch (r) {
			o = !0, n = r;
		} finally {
			try {
				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
					return;
				}
			} finally {
				if (o) {
					throw n;
				}
			}
		}
		return a;
	}
}
function _arrayWithHoles6(r) {
	if (Array.isArray(r)) {
		return r;
	}
}
function _createForOfIteratorHelper5(r, e) {
	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (!t) {
		if (Array.isArray(r) || (t = _unsupportedIterableToArray6(r)) || e && r && "number" == typeof r.length) {
			t && (r = t);
			var _n5 = 0,
				F = function F() {};
			return {
				s: F,
				n: function n() {
					return _n5 >= r.length ? {
						done: !0
					} : {
						done: !1,
						value: r[_n5++]
					};
				},
				e: function e(r) {
					throw r;
				},
				f: F
			};
		}
		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	var o,
		a = !0,
		u = !1;
	return {
		s: function s() {
			t = t.call(r);
		},
		n: function n() {
			var r = t.next();
			return a = r.done, r;
		},
		e: function e(r) {
			u = !0, o = r;
		},
		f: function f() {
			try {
				a || null == t["return"] || t["return"]();
			} finally {
				if (u) {
					throw o;
				}
			}
		}
	};
}
function _unsupportedIterableToArray6(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray6(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray6(r, a) : void 0;
	}
}
function _arrayLikeToArray6(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
function _slicedToArray5(r, e) {
	return _arrayWithHoles5(r) || _iterableToArrayLimit5(r, e) || _unsupportedIterableToArray5(r, e) || _nonIterableRest5();
}
function _nonIterableRest5() {
	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _iterableToArrayLimit5(r, l) {
	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (null != t) {
		var e,
			n,
			i,
			u,
			a = [],
			f = !0,
			o = !1;
		try {
			if (i = (t = t.call(r)).next, 0 === l) {
				if (Object(t) !== t) {
					return;
				}
				f = !1;
			} else {
				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
					;
				}
			}
		} catch (r) {
			o = !0, n = r;
		} finally {
			try {
				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
					return;
				}
			} finally {
				if (o) {
					throw n;
				}
			}
		}
		return a;
	}
}
function _arrayWithHoles5(r) {
	if (Array.isArray(r)) {
		return r;
	}
}
function _createForOfIteratorHelper4(r, e) {
	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (!t) {
		if (Array.isArray(r) || (t = _unsupportedIterableToArray5(r)) || e && r && "number" == typeof r.length) {
			t && (r = t);
			var _n4 = 0,
				F = function F() {};
			return {
				s: F,
				n: function n() {
					return _n4 >= r.length ? {
						done: !0
					} : {
						done: !1,
						value: r[_n4++]
					};
				},
				e: function e(r) {
					throw r;
				},
				f: F
			};
		}
		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	var o,
		a = !0,
		u = !1;
	return {
		s: function s() {
			t = t.call(r);
		},
		n: function n() {
			var r = t.next();
			return a = r.done, r;
		},
		e: function e(r) {
			u = !0, o = r;
		},
		f: function f() {
			try {
				a || null == t["return"] || t["return"]();
			} finally {
				if (u) {
					throw o;
				}
			}
		}
	};
}
function _unsupportedIterableToArray5(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray5(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray5(r, a) : void 0;
	}
}
function _arrayLikeToArray5(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
function _slicedToArray4(r, e) {
	return _arrayWithHoles4(r) || _iterableToArrayLimit4(r, e) || _unsupportedIterableToArray4(r, e) || _nonIterableRest4();
}
function _nonIterableRest4() {
	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _unsupportedIterableToArray4(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray4(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray4(r, a) : void 0;
	}
}
function _arrayLikeToArray4(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
function _iterableToArrayLimit4(r, l) {
	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (null != t) {
		var e,
			n,
			i,
			u,
			a = [],
			f = !0,
			o = !1;
		try {
			if (i = (t = t.call(r)).next, 0 === l) {
				if (Object(t) !== t) {
					return;
				}
				f = !1;
			} else {
				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
					;
				}
			}
		} catch (r) {
			o = !0, n = r;
		} finally {
			try {
				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
					return;
				}
			} finally {
				if (o) {
					throw n;
				}
			}
		}
		return a;
	}
}
function _arrayWithHoles4(r) {
	if (Array.isArray(r)) {
		return r;
	}
}
function _slicedToArray3(r, e) {
	return _arrayWithHoles3(r) || _iterableToArrayLimit3(r, e) || _unsupportedIterableToArray3(r, e) || _nonIterableRest3();
}
function _nonIterableRest3() {
	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _iterableToArrayLimit3(r, l) {
	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (null != t) {
		var e,
			n,
			i,
			u,
			a = [],
			f = !0,
			o = !1;
		try {
			if (i = (t = t.call(r)).next, 0 === l) {
				if (Object(t) !== t) {
					return;
				}
				f = !1;
			} else {
				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
					;
				}
			}
		} catch (r) {
			o = !0, n = r;
		} finally {
			try {
				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
					return;
				}
			} finally {
				if (o) {
					throw n;
				}
			}
		}
		return a;
	}
}
function _arrayWithHoles3(r) {
	if (Array.isArray(r)) {
		return r;
	}
}
function _createForOfIteratorHelper3(r, e) {
	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (!t) {
		if (Array.isArray(r) || (t = _unsupportedIterableToArray3(r)) || e && r && "number" == typeof r.length) {
			t && (r = t);
			var _n3 = 0,
				F = function F() {};
			return {
				s: F,
				n: function n() {
					return _n3 >= r.length ? {
						done: !0
					} : {
						done: !1,
						value: r[_n3++]
					};
				},
				e: function e(r) {
					throw r;
				},
				f: F
			};
		}
		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	var o,
		a = !0,
		u = !1;
	return {
		s: function s() {
			t = t.call(r);
		},
		n: function n() {
			var r = t.next();
			return a = r.done, r;
		},
		e: function e(r) {
			u = !0, o = r;
		},
		f: function f() {
			try {
				a || null == t["return"] || t["return"]();
			} finally {
				if (u) {
					throw o;
				}
			}
		}
	};
}
function _unsupportedIterableToArray3(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray3(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray3(r, a) : void 0;
	}
}
function _arrayLikeToArray3(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
function _slicedToArray2(r, e) {
	return _arrayWithHoles2(r) || _iterableToArrayLimit2(r, e) || _unsupportedIterableToArray2(r, e) || _nonIterableRest2();
}
function _nonIterableRest2() {
	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _iterableToArrayLimit2(r, l) {
	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (null != t) {
		var e,
			n,
			i,
			u,
			a = [],
			f = !0,
			o = !1;
		try {
			if (i = (t = t.call(r)).next, 0 === l) {
				if (Object(t) !== t) {
					return;
				}
				f = !1;
			} else {
				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
					;
				}
			}
		} catch (r) {
			o = !0, n = r;
		} finally {
			try {
				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
					return;
				}
			} finally {
				if (o) {
					throw n;
				}
			}
		}
		return a;
	}
}
function _arrayWithHoles2(r) {
	if (Array.isArray(r)) {
		return r;
	}
}
function _createForOfIteratorHelper2(r, e) {
	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (!t) {
		if (Array.isArray(r) || (t = _unsupportedIterableToArray2(r)) || e && r && "number" == typeof r.length) {
			t && (r = t);
			var _n2 = 0,
				F = function F() {};
			return {
				s: F,
				n: function n() {
					return _n2 >= r.length ? {
						done: !0
					} : {
						done: !1,
						value: r[_n2++]
					};
				},
				e: function e(r) {
					throw r;
				},
				f: F
			};
		}
		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	var o,
		a = !0,
		u = !1;
	return {
		s: function s() {
			t = t.call(r);
		},
		n: function n() {
			var r = t.next();
			return a = r.done, r;
		},
		e: function e(r) {
			u = !0, o = r;
		},
		f: function f() {
			try {
				a || null == t["return"] || t["return"]();
			} finally {
				if (u) {
					throw o;
				}
			}
		}
	};
}
function _unsupportedIterableToArray2(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray2(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0;
	}
}
function _arrayLikeToArray2(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
function _slicedToArray(r, e) {
	return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _nonIterableRest() {
	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _iterableToArrayLimit(r, l) {
	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (null != t) {
		var e,
			n,
			i,
			u,
			a = [],
			f = !0,
			o = !1;
		try {
			if (i = (t = t.call(r)).next, 0 === l) {
				if (Object(t) !== t) {
					return;
				}
				f = !1;
			} else {
				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
					;
				}
			}
		} catch (r) {
			o = !0, n = r;
		} finally {
			try {
				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
					return;
				}
			} finally {
				if (o) {
					throw n;
				}
			}
		}
		return a;
	}
}
function _arrayWithHoles(r) {
	if (Array.isArray(r)) {
		return r;
	}
}
function _createForOfIteratorHelper(r, e) {
	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (!t) {
		if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
			t && (r = t);
			var _n = 0,
				F = function F() {};
			return {
				s: F,
				n: function n() {
					return _n >= r.length ? {
						done: !0
					} : {
						done: !1,
						value: r[_n++]
					};
				},
				e: function e(r) {
					throw r;
				},
				f: F
			};
		}
		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	var o,
		a = !0,
		u = !1;
	return {
		s: function s() {
			t = t.call(r);
		},
		n: function n() {
			var r = t.next();
			return a = r.done, r;
		},
		e: function e(r) {
			u = !0, o = r;
		},
		f: function f() {
			try {
				a || null == t["return"] || t["return"]();
			} finally {
				if (u) {
					throw o;
				}
			}
		}
	};
}
function _unsupportedIterableToArray(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
	}
}
function _arrayLikeToArray(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
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);
	garden = new Garden();
	garden.init();
	game.addChild(garden);
	var flowerManager = new FlowerManager();
	game.flowerMatcher = new FlowerMatcher();
	game.addChild(game.flowerMatcher);
	var pollenTrail = new PollenTrail();
	game.addChild(pollenTrail);
	// Create bee and position above hive
	var bee = new Bee();
	bee.x = 2048 / 2;
	bee.y = 2732 / 2;
	game.addChild(bee);
	// Ensure pollen particles are rendered on top by adding them last
	game.setChildIndex(pollenTrail, game.children.length - 1);
	// Initialize bud spawner
	garden.budSpawner = new BudSpawner();
	garden.budSpawner.init(garden);
	game.addChild(garden.budSpawner);
	// Touch handlers
	game.down = function (x, y, obj) {
		bee.isMoving = true;
		bee.targetX = x;
		bee.targetY = y;
	};
	game.move = function (x, y, obj) {
		if (bee.isMoving) {
			bee.targetX = x;
			bee.targetY = y - 200;
		}
	};
	game.up = function (x, y, obj) {
		bee.isMoving = false;
	};
	// Initialize score display
	var scoreDisplay = new ScoreDisplay();
	scoreDisplay.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreDisplay);
	game.scoreDisplay = scoreDisplay;
	// Add the main update loop
	game.update = function () {
		// Update spawning system
		if (game.budSpawner) {
			game.budSpawner.update();
		}
		// Update trail system
		if (pollenTrail) {
			pollenTrail.update();
		}
		// Update garden elements
		if (garden) {
			// Update all flowers and buds in the grid
			for (var i = 0; i < garden.rows; i++) {
				for (var j = 0; j < garden.cols; j++) {
					var gridItem = garden.grid[i][j];
					if (gridItem && gridItem.update) {
						gridItem.update();
					}
				}
			}
		}
		// Update all children that have update methods
		for (var i = 0; i < game.children.length; i++) {
			var child = game.children[i];
			if (child && child.update) {
				child.update();
			}
		}
		// Update all particles
		if (game.particlesToUpdate) {
			for (var i = game.particlesToUpdate.length - 1; i >= 0; i--) {
				var particle = game.particlesToUpdate[i];
				if (particle && particle.update) {
					particle.update();
				}
			}
		}
		// Update bee
		if (bee && bee.update) {
			bee.update();
		}
	};
};
tutorialButton.down = function (x, y, obj) {
	// Open tutorial
};
// Removed duplicate playPollenPatternAnimation method

===================================================================
--- original.js
+++ change.js
@@ -611,10 +611,14 @@
 							}, {
 								duration: 1000,
 								ease: 'elasticOut',
 								onFinish: function onFinish() {
-									// Force immediate auto-bloom after scale animation
-									newBud.autoBloom();
+									// Set delayed auto-bloom after scale completes 
+									LK.setTimeout(function () {
+										if (newBud && newBud.parent && newBud.isBud && !newBud.isBeingReplaced) {
+											newBud.autoBloom();
+										}
+									}, index === 0 ? 180 : 300);
 								}
 							});
 						}
 					}, index * 200);