Upit | Learn about creating the game PetalPop: Year of the Bee with gen AI

Play

PetalPop: Year of the Bee

blackwidowink

PetalPop

423

3mo

Playit

A whimsical puzzle game where you control a bee to pollinate flowers across four seasons. Collect pollen, create hybrid colors, and match blooming flowers to progress. Master changing seasonal mechanics from spring pollinating to winter dance patterns.

#puzzle

#casual

#flowers

#garden

#vibrant

#UpitPuzzleContest

Creation History

User prompt

Please remove all gravity, drag, and air resistance related code from the FlowerMatcher's createPetalBurst function. The petals should only move outward and fade, using vx and vy for simple linear movement. Set a higher initial velocity (like 8-12) for the outward burst, and remove any references to oscillation, physics, or vertical acceleration.

User prompt

Please remove the handleGravity method from the FlowerMatcher class entirely, and remove any calls to handleGravity. We don't want flowers to fall down after matches - they should just be replaced with new buds that grow in the same spot.

User prompt

Update as necessary with: self.clearMatches = function(garden, matches) { matches.forEach(function(match) { var flower = match.flower; var worldPos = garden.gridToWorld(match.x, match.y); // Create petal burst self.createPetalBurst(worldPos.x, worldPos.y, flower.color); // Shrink animation tween(flower.scale, {x: 0, y: 0}, { duration: 500, onFinish: function() { garden.grid[match.y][match.x] = null; garden.removeChild(flower); // Create and grow new bud var newBud = new Bud(); newBud.x = worldPos.x; newBud.y = worldPos.y; newBud.scale.set(0, 0); garden.grid[match.y][match.x] = newBud; garden.addChild(newBud); tween(newBud.scale, {x: 1, y: 1}, { duration: 500, ease: 'elasticOut' }); } }); }); };

User prompt

Update as necessary: petal.update = function() { // Move outward this.x += this.vx; this.y += this.vy; // Slow down movement this.vx *= 0.95; this.vy *= 0.95; // Rotate this.rotation += this.rotationSpeed; // Fade out faster this.lifespan -= 0.05; this.alpha = this.lifespan; if (this.lifespan <= 0) { this.destroy(); } };

User prompt

Update as necessary with: // FlowerMatcher class to handle match-3 mechanics var FlowerMatcher = Container.expand(function() { var self = Container.call(this); // Check for matches after collecting pollen from a flower self.checkForMatches = function(garden, x, y) { console.log('Checking for matches at:', x, y); var matches = self.findMatches(garden, x, y); console.log('Found matches:', matches.length); if (matches.length >= 3) { console.log('Clearing matches!'); self.clearMatches(garden, matches); return true; } return false; }; // Find all matching flowers of the same color self.findMatches = function(garden, startX, startY) { var visited = {}; var matches = []; var startFlower = garden.grid[startY][startX]; console.log('Starting flower check:', startFlower); // Check if it's a valid flower to start matching from if (!startFlower || !startFlower.isFlower) { console.log('Not a valid flower to start matching'); return matches; } // We want to match dead flowers (those without active pollen) if (startFlower.hasActivePollen) { console.log('Starting flower still has active pollen'); return matches; } var flowerColor = startFlower.color; // Flood fill to find matching flowers var checkFlower = function(x, y) { // Check bounds if (x < 0 || x >= garden.cols || y < 0 || y >= garden.rows) { return; } // Check if already visited var key = x + ',' + y; if (visited[key]) { return; } visited[key] = true; var flower = garden.grid[y][x]; if (!flower || !flower.isFlower || flower.hasActivePollen) { return; } // Check if same color and dead if (flower.color === flowerColor && !flower.hasActivePollen) { console.log('Found matching flower at:', x, y, 'Color:', flower.color); matches.push({x: x, y: y, flower: flower}); // Check adjacent cells checkFlower(x + 1, y); checkFlower(x - 1, y); checkFlower(x, y + 1); checkFlower(x, y - 1); } }; // Start flood fill from initial position checkFlower(startX, startY); return matches; }; // Clear matched flowers with animation self.clearMatches = function(garden, matches) { matches.forEach(function(match) { var flower = match.flower; var worldPos = garden.gridToWorld(match.x, match.y); // Create petal burst effect self.createPetalBurst(worldPos.x, worldPos.y, flower.color); // Remove flower from grid and garden garden.grid[match.y][match.x] = null; garden.removeChild(flower); // Add score based on match size if (game.scoreManager) { game.scoreManager.addScore(100); } }); // After clearing, shift down any floating flowers self.handleGravity(garden); }; // Create petal burst particle effect self.createPetalBurst = function(x, y, color) { console.log('Creating petal burst for color:', color); var colorTints = { 'red': 0xFF0000, 'blue': 0x0000FF, 'yellow': 0xFFFF00, 'purple': 0x800080, 'orange': 0xFFA500, 'green': 0x00FF00 }; // Create multiple petal particles for (var i = 0; i < 12; i++) { var petal = new PollenParticle().init('burst'); var angle = (i / 12) * Math.PI * 2; petal.x = x; petal.y = y; petal.tint = colorTints[color]; petal.scale.set(0.8 + Math.random() * 0.4); // Enhanced petal movement physics petal.rotationSpeed = (Math.random() - 0.5) * 0.15; petal.vx = Math.cos(angle) * (8 + Math.random() * 4); petal.vy = Math.sin(angle) * (8 + Math.random() * 4) - 5; // Initial upward boost // Enhanced physics properties petal.gravity = 0.2; petal.drag = 0.98; petal.rotationPhase = Math.random() * Math.PI * 2; petal.oscillationSpeed = 0.05 + Math.random() * 0.05; // Override update method for more natural petal movement var originalUpdate = petal.update; petal.update = function() { // Apply gravity this.vy += this.gravity; // Apply air resistance this.vx *= this.drag; this.vy *= this.drag; // Add oscillating horizontal motion this.vx += Math.sin(LK.ticks * this.oscillationSpeed + this.rotationPhase) * 0.2; // Update rotation based on movement this.rotation += this.rotationSpeed; // Update position this.x += this.vx; this.y += this.vy; // Fade out faster this.lifespan -= 0.025; this.alpha = this.lifespan; // Remove when done if (this.lifespan <= 0) { this.destroy(); } }; game.addChild(petal); } }; // Handle gravity after clearing flowers self.handleGravity = function(garden) { var moved; do { moved = false; // Start from second-to-last row, moving upward for (var y = garden.rows - 2; y >= 0; y--) { for (var x = 0; x < garden.cols; x++) { var flower = garden.grid[y][x]; if (flower && flower.isFlower) { // Check if space below is empty if (!garden.grid[y + 1][x]) { // Move flower down garden.grid[y + 1][x] = flower; garden.grid[y][x] = null; // Animate the movement var newPos = garden.gridToWorld(x, y + 1); tween(flower, { x: newPos.x, y: newPos.y }, { duration: 300, ease: 'bounceOut' }); moved = true; } } } } } while (moved); }; // Initialize flower matcher game.flowerMatcher = new FlowerMatcher(); return self; });

User prompt

Add changes as necessary with: // FlowerMatcher class to handle match-3 mechanics var FlowerMatcher = Container.expand(function() { var self = Container.call(this); // Check for matches after collecting pollen from a flower self.checkForMatches = function(garden, x, y) { console.log('Checking for matches at:', x, y); var matches = self.findMatches(garden, x, y); console.log('Found matches:', matches.length); if (matches.length >= 3) { console.log('Clearing matches!'); self.clearMatches(garden, matches); return true; } return false; }; // Find all matching flowers of the same color self.findMatches = function(garden, startX, startY) { var visited = {}; var matches = []; var startFlower = garden.grid[startY][startX]; console.log('Starting flower check:', startFlower); // Check if it's a valid flower to start matching from if (!startFlower || !startFlower.isFlower) { console.log('Not a valid flower to start matching'); return matches; } // We want to match dead flowers (those without active pollen) if (startFlower.hasActivePollen) { console.log('Starting flower still has active pollen'); return matches; } var flowerColor = startFlower.color; // Flood fill to find matching flowers var checkFlower = function(x, y) { // Check bounds if (x < 0 || x >= garden.cols || y < 0 || y >= garden.rows) { return; } // Check if already visited var key = x + ',' + y; if (visited[key]) { return; } visited[key] = true; var flower = garden.grid[y][x]; if (!flower || !flower.isFlower || flower.hasActivePollen) { return; } // Check if same color and dead if (flower.color === flowerColor && !flower.hasActivePollen) { console.log('Found matching flower at:', x, y, 'Color:', flower.color); matches.push({x: x, y: y, flower: flower}); // Check adjacent cells checkFlower(x + 1, y); checkFlower(x - 1, y); checkFlower(x, y + 1); checkFlower(x, y - 1); } }; // Start flood fill from initial position checkFlower(startX, startY); return matches; }; // Clear matched flowers with animation self.clearMatches = function(garden, matches) { matches.forEach(function(match) { var flower = match.flower; var worldPos = garden.gridToWorld(match.x, match.y); // Create petal burst effect self.createPetalBurst(worldPos.x, worldPos.y, flower.color); // Remove flower from grid and garden garden.grid[match.y][match.x] = null; garden.removeChild(flower); // Add score based on match size if (game.scoreManager) { game.scoreManager.addScore(100); } }); // After clearing, shift down any floating flowers self.handleGravity(garden); }; // Create petal burst particle effect self.createPetalBurst = function(x, y, color) { console.log('Creating petal burst for color:', color); var colorTints = { 'red': 0xFF0000, 'blue': 0x0000FF, 'yellow': 0xFFFF00, 'purple': 0x800080, 'orange': 0xFFA500, 'green': 0x00FF00 }; // Create multiple petal particles for (var i = 0; i < 12; i++) { var petal = new PollenParticle().init('burst'); var angle = (i / 12) * Math.PI * 2; petal.x = x; petal.y = y; petal.tint = colorTints[color]; petal.scale.set(0.8 + Math.random() * 0.4); // Enhanced petal movement physics petal.rotationSpeed = (Math.random() - 0.5) * 0.15; petal.vx = Math.cos(angle) * (8 + Math.random() * 4); petal.vy = Math.sin(angle) * (8 + Math.random() * 4) - 5; // Initial upward boost // Enhanced physics properties petal.gravity = 0.2; petal.drag = 0.98; petal.rotationPhase = Math.random() * Math.PI * 2; petal.oscillationSpeed = 0.05 + Math.random() * 0.05; // Override update method for more natural petal movement var originalUpdate = petal.update; petal.update = function() { // Apply gravity this.vy += this.gravity; // Apply air resistance this.vx *= this.drag; this.vy *= this.drag; // Add oscillating horizontal motion this.vx += Math.sin(LK.ticks * this.oscillationSpeed + this.rotationPhase) * 0.2; // Update rotation based on movement this.rotation += this.rotationSpeed; // Update position this.x += this.vx; this.y += this.vy; // Fade out faster this.lifespan -= 0.025; this.alpha = this.lifespan; // Remove when done if (this.lifespan <= 0) { this.destroy(); } }; game.addChild(petal); } }; // Handle gravity after clearing flowers self.handleGravity = function(garden) { var moved; do { moved = false; // Start from second-to-last row, moving upward for (var y = garden.rows - 2; y >= 0; y--) { for (var x = 0; x < garden.cols; x++) { var flower = garden.grid[y][x]; if (flower && flower.isFlower) { // Check if space below is empty if (!garden.grid[y + 1][x]) { // Move flower down garden.grid[y + 1][x] = flower; garden.grid[y][x] = null; // Animate the movement var newPos = garden.gridToWorld(x, y + 1); tween(flower, { x: newPos.x, y: newPos.y }, { duration: 300, ease: 'bounceOut' }); moved = true; } } } } } while (moved); }; // Initialize flower matcher game.flowerMatcher = new FlowerMatcher(); return self; });

User prompt

Please fix the bug: 'TypeError: undefined is not an object (evaluating 'garden.grid[startY][startX]')' in or related to this line: 'var startFlower = garden.grid[startY][startX];' Line Number: 438

User prompt

Update as necessary with: self.collectPollen = function(flower) { if (self.currentPollen < self.maxPollen && flower.hasActivePollen && !flower.pollenCollected) { // ... existing collection code ... flower.pollenCollected = true; flower.hasActivePollen = false; flower.removeFairyParticles(); // Add this new block for match checking var localPos = garden.toLocal({x: flower.x, y: flower.y}, game); var gridX = Math.floor(localPos.x / garden.cellSize); var gridY = Math.floor(localPos.y / garden.cellSize); // Check for matches after flower becomes dead if (game.flowerMatcher) { game.flowerMatcher.checkForMatches(garden, gridX, gridY); } // ... rest of the existing code ... } };

User prompt

Add this under where Bee is added to game: // Create and initialize the flower matcher game.flowerMatcher = new FlowerMatcher(); game.addChild(game.flowerMatcher);

User prompt

Add this code: // FlowerMatcher class to handle match-3 mechanics var FlowerMatcher = Container.expand(function() { var self = Container.call(this); // Check for matches after collecting pollen from a flower 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; }; // Find all matching flowers of the same color self.findMatches = function(garden, startX, startY) { var visited = {}; var matches = []; var startFlower = garden.grid[startY][startX]; if (!startFlower || !startFlower.isFlower || startFlower.hasActivePollen) { return matches; } var flowerColor = startFlower.color; // Flood fill to find matching flowers var checkFlower = function(x, y) { // Check bounds if (x < 0 || x >= garden.cols || y < 0 || y >= garden.rows) { return; } // Check if already visited var key = x + ',' + y; if (visited[key]) { return; } visited[key] = true; var flower = garden.grid[y][x]; if (!flower || !flower.isFlower || flower.hasActivePollen) { return; } // Check if same color and dead if (flower.color === flowerColor && !flower.hasActivePollen) { matches.push({x: x, y: y, flower: flower}); // Check adjacent cells checkFlower(x + 1, y); checkFlower(x - 1, y); checkFlower(x, y + 1); checkFlower(x, y - 1); } }; // Start flood fill from initial position checkFlower(startX, startY); return matches; }; // Clear matched flowers with animation self.clearMatches = function(garden, matches) { matches.forEach(function(match) { var flower = match.flower; var worldPos = garden.gridToWorld(match.x, match.y); // Create petal burst effect self.createPetalBurst(worldPos.x, worldPos.y, flower.color); // Remove flower from grid and garden garden.grid[match.y][match.x] = null; garden.removeChild(flower); // Add score based on match size if (game.scoreManager) { game.scoreManager.addScore(100); } }); // After clearing, shift down any floating flowers self.handleGravity(garden); }; // Create petal burst particle effect self.createPetalBurst = function(x, y, color) { var colorTints = { 'red': 0xFF0000, 'blue': 0x0000FF, 'yellow': 0xFFFF00, 'purple': 0x800080, 'orange': 0xFFA500, 'green': 0x008000 }; // Create multiple petal particles for (var i = 0; i < 12; i++) { var petal = new PollenParticle().init('burst'); var angle = (i / 12) * Math.PI * 2; petal.x = x; petal.y = y; petal.tint = colorTints[color]; petal.scale.set(0.8 + Math.random() * 0.4); // Add rotational velocity for petal-like movement petal.rotationSpeed = (Math.random() - 0.5) * 0.2; petal.vx = Math.cos(angle) * (3 + Math.random() * 2); petal.vy = Math.sin(angle) * (3 + Math.random() * 2); // Add slight gravity effect petal.gravity = 0.1; // Override update method for petals var originalUpdate = petal.update; petal.update = function() { // Apply gravity this.vy += this.gravity; // Add slight horizontal drift this.vx *= 0.98; // Call original particle update originalUpdate.call(this); }; game.addChild(petal); } }; // Handle gravity after clearing flowers self.handleGravity = function(garden) { var moved; do { moved = false; // Start from second-to-last row, moving upward for (var y = garden.rows - 2; y >= 0; y--) { for (var x = 0; x < garden.cols; x++) { var flower = garden.grid[y][x]; if (flower && flower.isFlower) { // Check if space below is empty if (!garden.grid[y + 1][x]) { // Move flower down garden.grid[y + 1][x] = flower; garden.grid[y][x] = null; // Animate the movement var newPos = garden.gridToWorld(x, y + 1); tween(flower, { x: newPos.x, y: newPos.y }, { duration: 300, ease: 'bounceOut' }); moved = true; } } } } } while (moved); }; return self; });

User prompt

Update with this: // Red cell initialization and position var redCell = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0.5, x: -300 // Set position in initialization }); redCell.tint = 0xFF0000; redCell.alpha = 0.4; self.addChild(redCell); self.redFill = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0, x: -300 // Set position in initialization }); self.redFill.tint = 0xFF0000; self.redFill.alpha = 0.7; self.redFill.y = 90; self.redFill.scale.y = 0; self.addChild(self.redFill); // Blue cell initialization and position var blueCell = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0.5, x: 0 // Set position in initialization }); blueCell.tint = 0x0000FF; blueCell.alpha = 0.4; self.addChild(blueCell); self.blueFill = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0, x: 0 // Set position in initialization }); self.blueFill.tint = 0x0000FF; self.blueFill.alpha = 0.7; self.blueFill.y = 90; self.blueFill.scale.y = 0; self.addChild(self.blueFill); // Yellow cell initialization and position var yellowCell = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0.5, x: 300 // Set position in initialization }); yellowCell.tint = 0xFFFF00; yellowCell.alpha = 0.4; self.addChild(yellowCell); self.yellowFill = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0, x: 300 // Set position in initialization }); self.yellowFill.tint = 0xFFFF00; self.yellowFill.alpha = 0.7; self.yellowFill.y = 90; self.yellowFill.scale.y = 0; self.addChild(self.yellowFill);

User prompt

Please fix the bug: 'Script error.' in or related to this line: 'self.yellowFill.x = 300;' Line Number: 838

User prompt

Please fix the bug: 'Script error.' in or related to this line: 'self.redFill.x = -300;' Line Number: 802

User prompt

Adjust spacing of cells with this: // Decrease spacing between cells (adjust x values) redCell.x = -300; // Was -420 yellowCell.x = 300; // Was 420 // Adjust fill indicators to match new positions self.redFill.x = -300; self.yellowFill.x = 300;

User prompt

Adjust cell visibility in pollen ui: // Increase base cell visibility redCell.alpha = 0.4; // Was 0.3 blueCell.alpha = 0.4; yellowCell.alpha = 0.4;

User prompt

Update only as necessary with: // In Hive's collectFromBee method, make sure we're creating the particles: self.collectFromBee = function(bee) { if (bee.currentPollen > 0) { // 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); } // ... rest of collection code ... } };

User prompt

Add the bud asset underneath the flower asset in the BasicFlower class

User prompt

Please fix the bug: 'Script error.' in or related to this line: 'self.redFill.x = -360;' Line Number: 789

User prompt

Reduce the spacing between the pollen UI cells. Adjust nothing else.

User prompt

Please fix the bug: 'Script error.' in or related to this line: 'yellowCell.x = 300;' Line Number: 799

User prompt

Please fix the bug: 'Script error.' in or related to this line: 'self.redFill.x = -300;' Line Number: 789

User prompt

Reduce the spacing between pollen UI cells

User prompt

Update as necessary using: self.updatePollen = function(color, amount, max) { var fillAmount = Math.min(amount / max, 1); if (color === 'red') { self.redFill.scale.y = fillAmount; self.redFill.y = 90 - (180 * fillAmount); // Start at 90, move up as it fills } else if (color === 'blue') { self.blueFill.scale.y = fillAmount; self.blueFill.y = 90 - (180 * fillAmount); } else if (color === 'yellow') { self.yellowFill.scale.y = fillAmount; self.yellowFill.y = 90 - (180 * fillAmount); } };

User prompt

Make updates as necessary: // Change these properties for each fill indicator (red, blue, and yellow): self.redFill = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0 // Changed from 1 to 0 }); self.redFill.y = 90; // Add this line // Same changes for blue and yellow: self.blueFill = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0 }); self.blueFill.y = 90; self.yellowFill = LK.getAsset('pollenCellBase', { anchorX: 0.5, anchorY: 0 }); self.yellowFill.y = 90;

/**** 
* 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() {
				// After bloom animation, delay before activating pollen
				LK.setTimeout(function () {
					self.hasActivePollen = true;
					// Create fairy particles after delay
					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);
					}
				}, 1000); // 1 second delay after bloom before pollen activates
			}
		});
		// 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 = false; // New flag to track if we've collected from it
});
var Bee = Container.expand(function () {
	var self = Container.call(this);
	// Create bee sprite
	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 = 50; // Cap pollen amount
	self.currentPollen = 0; // Current amount being carried
	self.pollenTypes = []; // Array to track different pollen colors
	// Format: [{color: 'red', amount: 30}, ...]
	self.pollenMeter = new PollenMeter();
	self.pollenMeter.y = -50; // Position above bee
	self.addChild(self.pollenMeter);
	// 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.hasActivePollen && !flower.pollenCollected) {
			var collectAmount = 25;
			// 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
				});
			}
			// Set currentPollen to match total of all types
			self.currentPollen = self.pollenTypes.reduce(function (total, type) {
				return total + type.amount;
			}, 0);
			flower.pollenCollected = true;
			flower.hasActivePollen = false;
			flower.removeFairyParticles();
			// Add this new block for match checking
			var localPos = garden.toLocal({
				x: flower.x,
				y: flower.y
			}, game);
			var gridX = Math.floor(localPos.x / garden.cellSize);
			var gridY = Math.floor(localPos.y / garden.cellSize);
			// Check for matches after flower becomes dead
			if (game.flowerMatcher) {
				game.flowerMatcher.checkForMatches(garden, gridX, gridY);
			}
			// Update UI
			game.beeUI.updatePollen(flower.color, self.currentPollen, self.maxPollen); // Update UI using game.beeUI
			// Update meter
			self.pollenMeter.updateMeter(self.currentPollen, self.maxPollen);
		}
	};
	self.checkFlowerCollision = function () {
		// Convert bee position to garden's local space
		var localPos = garden.toLocal({
			x: self.x,
			y: self.y
		}, game);
		// Calculate grid position
		var gridX = Math.floor(localPos.x / garden.cellSize);
		var gridY = Math.floor(localPos.y / garden.cellSize);
		console.log('Grid Position:', gridX, gridY); // Debug
		// 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) {
				console.log('Grid Item:', gridItem.isBud, self.currentPollen); // Debug
				if (gridItem.isFlower && gridItem.hasActivePollen) {
					// Collect pollen from flower
					self.collectPollen(gridItem);
				} else if (gridItem && gridItem.isBud && self.currentPollen > 0) {
					// Add immediate state check and lock
					if (gridItem.isBeingPollinated) {
						return;
					} // Skip if already being converted
					gridItem.isBeingPollinated = true;
					console.log('Attempting pollination'); // Debug
					var pollenColor = self.usePollen(gridItem);
					if (pollenColor) {
						// Ensure the bud hasn't auto-bloomed
						if (garden.grid[gridY][gridX] === gridItem) {
							console.log('Pollination successful'); // Debug
							// Convert bud to flower with the correct color
							var newFlower = new BasicFlower(pollenColor);
							newFlower.x = gridItem.x;
							newFlower.y = gridItem.y;
							newFlower.isFlower = true;
							garden.removeChild(gridItem);
							garden.grid[gridY][gridX] = newFlower;
							garden.addChild(newFlower);
							newFlower.bloom();
						}
					}
				}
			}
		}
	};
	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
		console.log('Trying to use pollen. Amount:', self.currentPollen);
		console.log('Pollen types:', self.pollenTypes);
		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;
			// Update UI
			game.beeUI.updatePollen(color, self.currentPollen, self.maxPollen); // Update UI using game.beeUI 
			// 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;
	// 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) {
			return;
		} // Prevent double-blooming
		// Get grid position
		var localPos = garden.toLocal({
			x: self.x,
			y: self.y
		}, game);
		var gridX = Math.floor(localPos.x / garden.cellSize);
		var gridY = Math.floor(localPos.y / garden.cellSize);
		// 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; // Auto-bloomed flowers start dead
		// Update grid
		if (garden.grid[gridY] && garden.grid[gridY][gridX] === self) {
			garden.removeChild(self);
			garden.grid[gridY][gridX] = newFlower;
			garden.addChild(newFlower);
			newFlower.bloom();
		}
		self.isBud = false;
	};
	return self;
});
// Add BudSpawner to handle progressive difficulty
var BudSpawner = Container.expand(function () {
	var self = Container.call(this);
	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.getSpawnRate = function () {
		// Keep original timing logic
		return 16; // Spawn every frame for immediate filling
	};
	self.update = function () {
		self.gameTime = LK.ticks / 60;
		// Count down to next bloom
		if (self.nextBloomTime > 0) {
			self.nextBloomTime--;
			if (self.nextBloomTime <= 0) {
				// Find a random bud to bloom
				var validBuds = [];
				for (var i = 0; i < self.garden.rows; i++) {
					for (var j = 0; j < self.garden.cols; j++) {
						var gridItem = self.garden.grid[i][j];
						if (gridItem && gridItem.isBud) {
							validBuds.push({
								item: gridItem,
								x: j,
								y: i
							});
						}
					}
				}
				if (validBuds.length > 0) {
					// Pick a random bud
					var randomIndex = Math.floor(Math.random() * validBuds.length);
					var selectedBud = validBuds[randomIndex];
					// Create the flower
					var flowerColors = ['red', 'blue', 'yellow'];
					var randomColor = flowerColors[Math.floor(Math.random() * flowerColors.length)];
					var newFlower = new BasicFlower(randomColor);
					newFlower.x = selectedBud.item.x;
					newFlower.y = selectedBud.item.y;
					newFlower.isFlower = true;
					newFlower.hasActivePollen = false; // Auto-bloomed flowers start without pollen
					// Update grid
					self.garden.removeChild(selectedBud.item);
					self.garden.grid[selectedBud.y][selectedBud.x] = newFlower;
					self.garden.addChild(newFlower);
					newFlower.bloom();
					// Set timer for next bloom (15-20 seconds)
					self.nextBloomTime = (15 + Math.random() * 5) * 60;
				}
			}
		}
	};
});
// 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);
	// Check for matches after collecting pollen from a flower
	self.checkForMatches = function (garden, x, y) {
		console.log('Checking for matches at:', x, y);
		var matches = self.findMatches(garden, x, y);
		console.log('Found matches:', matches.length);
		if (matches.length >= 3) {
			console.log('Clearing matches!');
			self.clearMatches(garden, matches);
			return true;
		}
		return false;
	};
	// Find all matching flowers of the same color
	self.findMatches = function (garden, startX, startY) {
		var visited = {};
		var matches = [];
		if (!garden.grid[startY] || !garden.grid[startY][startX]) {
			return matches;
		}
		var startFlower = garden.grid[startY][startX];
		console.log('Starting flower check:', startFlower);
		// Check if it's a valid flower to start matching from
		if (!startFlower || !startFlower.isFlower) {
			console.log('Not a valid flower to start matching');
			return matches;
		}
		// We want to match dead flowers (those without active pollen)
		if (startFlower.hasActivePollen) {
			console.log('Starting flower still has active pollen');
			return matches;
		}
		var flowerColor = startFlower.color;
		// Flood fill to find matching flowers
		var _checkFlower = function checkFlower(x, y) {
			// Check bounds
			if (x < 0 || x >= garden.cols || y < 0 || y >= garden.rows) {
				return;
			}
			// Check if already visited
			var key = x + ',' + y;
			if (visited[key]) {
				return;
			}
			visited[key] = true;
			var flower = garden.grid[y][x];
			if (!flower || !flower.isFlower || flower.hasActivePollen) {
				return;
			}
			// Check if same color and dead
			if (flower.color === flowerColor && !flower.hasActivePollen) {
				console.log('Found matching flower at:', x, y, 'Color:', flower.color);
				matches.push({
					x: x,
					y: y,
					flower: flower
				});
				// Check adjacent cells
				_checkFlower(x + 1, y);
				_checkFlower(x - 1, y);
				_checkFlower(x, y + 1);
				_checkFlower(x, y - 1);
			}
		};
		// Start flood fill from initial position
		_checkFlower(startX, startY);
		return matches;
	};
	// Clear matched flowers with animation
	self.clearMatches = function (garden, matches) {
		matches.forEach(function (match) {
			var flower = match.flower;
			var worldPos = garden.gridToWorld(match.x, match.y);
			// Create petal burst
			self.createPetalBurst(worldPos.x, worldPos.y, flower.color);
			// Shrink animation
			tween(flower.scale, {
				x: 0,
				y: 0
			}, {
				duration: 500,
				onFinish: function onFinish() {
					garden.grid[match.y][match.x] = null;
					garden.removeChild(flower);
					// Create and grow new bud
					var newBud = new Bud();
					newBud.x = worldPos.x;
					newBud.y = worldPos.y;
					newBud.scale.set(0, 0);
					garden.grid[match.y][match.x] = newBud;
					garden.addChild(newBud);
					tween(newBud.scale, {
						x: 1,
						y: 1
					}, {
						duration: 500,
						ease: 'elasticOut'
					});
				}
			});
			// Add score based on match size
			if (game.scoreManager) {
				game.scoreManager.addScore(100);
			}
		});
	};
	// Create petal burst particle effect
	self.createPetalBurst = function (x, y, color) {
		console.log('Creating petal burst for color:', color);
		var colorTints = {
			'red': 0xFF0000,
			'blue': 0x0000FF,
			'yellow': 0xFFFF00,
			'purple': 0x800080,
			'orange': 0xFFA500,
			'green': 0x008000
		};
		// Create multiple petal particles
		for (var i = 0; i < 12; i++) {
			var petal = new PollenParticle().init('burst');
			var angle = i / 12 * Math.PI * 2;
			petal.x = x;
			petal.y = y;
			petal.tint = colorTints[color];
			petal.scale.set(0.8 + Math.random() * 0.4);
			// Add rotational velocity for petal-like movement
			petal.rotationSpeed = (Math.random() - 0.5) * 0.2;
			petal.vx = Math.cos(angle) * (3 + Math.random() * 2);
			petal.vy = Math.sin(angle) * (3 + Math.random() * 2);
			// Override update method for petals
			var originalUpdate = petal.update;
			petal.update = function () {
				// Call original particle update
				originalUpdate.call(this);
			};
			game.addChild(petal);
		}
	};
	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 = 225;
	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 and fill with buds
		for (var i = 0; i < self.rows; i++) {
			self.grid[i] = [];
			for (var j = 0; j < self.cols; j++) {
				var bud = new Bud();
				bud.x = j * self.cellSize + self.cellSize / 2;
				bud.y = i * self.cellSize + self.cellSize / 2;
				bud.isBud = true;
				bud.isFlower = false;
				self.grid[i][j] = bud;
				self.addChild(bud);
			}
		}
	};
	// Helper method to convert grid position to world position
	self.gridToWorld = function (gridX, gridY) {
		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('GardenBackground', {
		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;
				// Update hive UI
				game.hiveUI.updatePollen(type.color, self.storedPollen[type.color], 1000); // Update UI using game.hiveUI
			});
			// 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 = [];
			// Update bee UI to show empty
			['red', 'blue', 'yellow'].forEach(function (color) {
				game.beeUI.updatePollen(color, 0, bee.maxPollen); // Clear bee's pollen using game.beeUI
			});
			// 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 pollenGraphics = self.attachAsset('PollenSparkle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Initialize with random properties for more organic feel
	self.init = function (type) {
		self.type = type || 'trail';
		// 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
		// Move outward
		self.x += self.vx;
		self.y += self.vy;
		// Slow down movement
		self.vx *= 0.95;
		self.vy *= 0.95;
		// Rotate
		self.rotation += self.rotationSpeed;
		// Fade out faster
		self.lifespan -= 0.05;
		self.alpha = self.lifespan;
		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) {
		self.active = true;
		self.points = [{
			x: x,
			y: y,
			time: Date.now()
		}];
		self.startTime = Date.now();
		self.trailStartTime = Date.now(); // Record start time
		self.currentGarden = garden; // Store garden reference
		self.lastPoint = {
			x: x,
			y: y
		};
	};
	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');
		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();
			}
		}
	};
});
var PollenUI = Container.expand(function () {
	var self = Container.call(this);
	// Create cells with their fill indicators
	// Red cell and fill
	// Red cell initialization and position
	var redCell = LK.getAsset('pollenCellBase', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -300 // Set position in initialization
	});
	redCell.tint = 0xFF0000;
	redCell.alpha = 0.4;
	self.addChild(redCell);
	self.redFill = LK.getAsset('pollenCellBase', {
		anchorX: 0.5,
		anchorY: 0,
		x: -300 // Set position in initialization
	});
	self.redFill.tint = 0xFF0000;
	self.redFill.alpha = 0.7;
	self.redFill.y = 90;
	self.redFill.scale.y = 0;
	self.addChild(self.redFill);
	// Blue cell initialization and position
	var blueCell = LK.getAsset('pollenCellBase', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0 // Set position in initialization
	});
	blueCell.tint = 0x0000FF;
	blueCell.alpha = 0.4;
	self.addChild(blueCell);
	self.blueFill = LK.getAsset('pollenCellBase', {
		anchorX: 0.5,
		anchorY: 0,
		x: 0 // Set position in initialization
	});
	self.blueFill.tint = 0x0000FF;
	self.blueFill.alpha = 0.7;
	self.blueFill.y = 90;
	self.blueFill.scale.y = 0;
	self.addChild(self.blueFill);
	// Yellow cell initialization and position
	var yellowCell = LK.getAsset('pollenCellBase', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 300 // Set position in initialization
	});
	yellowCell.tint = 0xFFFF00;
	yellowCell.alpha = 0.4;
	self.addChild(yellowCell);
	self.yellowFill = LK.getAsset('pollenCellBase', {
		anchorX: 0.5,
		anchorY: 0,
		x: 300 // Set position in initialization
	});
	self.yellowFill.tint = 0xFFFF00;
	self.yellowFill.alpha = 0.7;
	self.yellowFill.y = 90;
	self.yellowFill.scale.y = 0;
	self.addChild(self.yellowFill);
	// Add update method
	self.updatePollen = function (color, amount, max) {
		var fillAmount = Math.min(amount / max, 1);
		if (color === 'red') {
			self.redFill.scale.y = fillAmount;
			self.redFill.y = 90 - 180 * fillAmount; // Start at 90, move up as it fills
		} else if (color === 'blue') {
			self.blueFill.scale.y = fillAmount;
			self.blueFill.y = 90 - 180 * fillAmount;
		} else if (color === 'yellow') {
			self.yellowFill.scale.y = fillAmount;
			self.yellowFill.y = 90 - 180 * fillAmount;
		}
	};
	return self;
});
// 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();
		}
	};
});
// 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);
	garden = new Garden();
	garden.init();
	game.addChild(garden);
	var flowerManager = new FlowerManager();
	game.flowerManager = flowerManager;
	var pollenTrail = new PollenTrail();
	game.addChild(pollenTrail);
	// Create and position hive
	var hive = new Hive();
	hive.x = 2048 / 2;
	hive.y = 2732 * 0.97 - 200;
	// Create bee and position above hive
	var bee = new Bee();
	bee.x = hive.x;
	bee.y = hive.y - 150;
	// Create UI and attach to game object so it's globally accessible
	game.beeUI = new PollenUI();
	game.beeUI.position.set(hive.x - 600, hive.y + 100);
	game.beeUI.scale.set(0.8);
	game.addChild(game.beeUI);
	game.hiveUI = new PollenUI();
	game.hiveUI.position.set(hive.x + 600, hive.y + 100);
	game.addChild(game.hiveUI);
	// Add objects to game
	game.flowerMatcher = new FlowerMatcher();
	game.addChild(game.flowerMatcher);
	game.addChild(hive);
	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();
			// Collision detection between bee and hive
			if (hive) {
				var dx = bee.x - hive.x;
				var dy = bee.y - hive.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < 100) {
					// Adjust collection radius as needed
					hive.collectFromBee(bee);
				}
			}
		}
	};
};
tutorialButton.down = function (x, y, obj) {
	// Open tutorial
};
// Removed duplicate playPollenPatternAnimation method

===================================================================
--- original.js
+++ change.js
@@ -526,17 +526,11 @@
 			// Add rotational velocity for petal-like movement
 			petal.rotationSpeed = (Math.random() - 0.5) * 0.2;
 			petal.vx = Math.cos(angle) * (3 + Math.random() * 2);
 			petal.vy = Math.sin(angle) * (3 + Math.random() * 2);
-			// Add slight gravity effect
-			petal.gravity = 0.1;
 			// Override update method for petals
 			var originalUpdate = petal.update;
 			petal.update = function () {
-				// Apply gravity
-				this.vy += this.gravity;
-				// Add slight horizontal drift
-				this.vx *= 0.98;
 				// Call original particle update
 				originalUpdate.call(this);
 			};
 			game.addChild(petal);

Showing 1451 to 1475 of 2018

1 ...57 58 59 60 61 ...81

Images

A background image for a puzzle video game depicting the season of summer. Cartoon.
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

A background image for a puzzle video game depicting the season of fall. Cartoon.
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

A background image for a puzzle video game depicting the season of winter. Cartoon.
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Multiple stylized texts with phrases that include “Hurry!” “Time’s up!” Cartoon style..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create a SVG text design in bold cartoon style: "SPRING" in chunky rounded letters with floral accents and vines. Use spring pastels..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create an SVG text design for "SUMMER" in bold cartoon style with chunky rounded letters. Add sun rays and small flower details in warm, vibrant colors..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create an SVG text design for "FALL" in bold cartoon style with chunky rounded letters. Add small falling leaves and acorn accents in warm autumn colors..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create an SVG text design for "WINTER" in bold cartoon style with chunky rounded letters. Add small snowflake accents and icy details in cool, frosty blues and white..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create a SVG text design in bold cartoon style: “Bloom the garden" in chunky rounded letters with floral accents and vines. Use spring pastels..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create an SVG text design for "Match the blooms" in bold cartoon style with chunky rounded letters. Add sun rays and small flower details in warm, vibrant colors..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create an SVG text design for "Match to clear leaves" in bold cartoon style with chunky rounded letters. Add small falling leaves and acorn accents in warm autumn colors..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create an SVG text design for "DANCE TO STAY WARM" in bold cartoon style with chunky rounded letters. Add small snowflake accents and icy details in cool, frosty blues and white..
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Create a SVG text design in bold cartoon style: "SEASON COMPLETE!" in chunky rounded letters with stars around it .
Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.

Sounds & Music

🎵

Pop

Sound effect

Main