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

Play

PetalPop: Year of the Bee

blackwidowink

PetalPop

421

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

Update game up with this code: game.up = function(x, y, obj) { if (pollenTrail && pollenTrail.active) { pollenTrail.endTrail(garden); } };

User prompt

Please fix the bug: 'Script error.' in or related to this line: 'var localPos = garden.toLocal({' Line Number: 318

User prompt

Make updates to PollenTrail class with those code block, do not replace all code, just that which needs update: // Only modify the endTrail method in your working PollenTrail class var PollenTrail = Container.expand(function() { // Keep all your existing working code the same // Just replace the endTrail method with this: self.endTrail = function(garden) { if (!self.active) return; // Find affected buds var affectedBuds = []; var checkedPositions = {}; self.trailPoints.forEach(function(point) { var localPos = garden.toLocal({x: point.x, y: point.y}, game); var gridX = Math.floor(localPos.x / garden.cellSize); var gridY = Math.floor(localPos.y / garden.cellSize); var posKey = gridX + ',' + gridY; if (!checkedPositions[posKey] && gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) { checkedPositions[posKey] = true; var gridItem = garden.grid[gridY][gridX]; if (gridItem && gridItem.isBud && !gridItem.isFlower) { affectedBuds.push({ bud: gridItem, gridX: gridX, gridY: gridY }); } } }); // Convert buds to flowers if we have at least 2 if (affectedBuds.length >= 2) { affectedBuds.forEach(function(budInfo) { // Remove the bud garden.removeChild(budInfo.bud); // Create new flower var newFlower = new BasicFlower(); newFlower.x = budInfo.bud.x; newFlower.y = budInfo.bud.y; newFlower.isFlower = true; newFlower.scale.set(0.3, 0.3); // Add bloom animation LK.tween(newFlower.scale) .to({x: 1, y: 1}, 1000) .start(); garden.grid[budInfo.gridY][budInfo.gridX] = newFlower; garden.addChild(newFlower); }); } self.active = false; self.trailPoints = []; }; });

User prompt

Make updates with this code: // Declare pollenTrail in global scope var pollenTrail; var PollenTrail = Container.expand(function() { var self = Container.call(this); self.active = false; self.lastParticleTime = 0; self.trailPoints = []; self.TRAIL_DURATION = 2500; // 2.5 seconds in milliseconds self.MAX_DISTANCE = 200; // Maximum distance between points self.update = function() { // Remove points that are too old var currentTime = Date.now(); self.trailPoints = self.trailPoints.filter(function(point) { return currentTime - point.time < self.TRAIL_DURATION; }); // Update particles if any need updating if (game.particlesToUpdate) { for (var i = game.particlesToUpdate.length - 1; i >= 0; i--) { var particle = game.particlesToUpdate[i]; if (particle && particle.update) { particle.update(); } } } }; self.startTrail = function(x, y) { self.active = true; self.trailPoints = [{ x: x, y: y, time: Date.now() }]; self.createParticle(x, y); self.lastPoint = {x: x, y: y}; }; self.updateTrail = function(x, y) { if (!self.active) return; var currentTime = Date.now(); // Check distance from last point if (self.lastPoint) { var dx = x - self.lastPoint.x; var dy = y - self.lastPoint.y; var distance = Math.sqrt(dx * dx + dy * dy); // Only add new point if we've moved far enough if (distance > 10) { // Minimum distance between points self.trailPoints.push({ x: x, y: y, time: currentTime }); self.lastPoint = {x: x, y: y}; // Create particle if (currentTime - self.lastParticleTime >= 50) { // Control particle creation rate self.createParticle(x, y); self.lastParticleTime = currentTime; } } } }; self.createParticle = function(x, y) { var particle = new PollenParticle(); particle.x = x; particle.y = y; game.addChild(particle); }; self.endTrail = function(garden) { if (!self.active) return; // Filter out old points var currentTime = Date.now(); self.trailPoints = self.trailPoints.filter(function(point) { return currentTime - point.time < self.TRAIL_DURATION; }); // Find all buds affected by the valid trail points var affectedBuds = []; var checkedPositions = {}; self.trailPoints.forEach(function(point) { var localPos = garden.toLocal({x: point.x, y: point.y}, game); var gridX = Math.floor(localPos.x / garden.cellSize); var gridY = Math.floor(localPos.y / garden.cellSize); var posKey = gridX + ',' + gridY; if (!checkedPositions[posKey] && gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) { checkedPositions[posKey] = true; var gridItem = garden.grid[gridY][gridX]; if (gridItem && gridItem.isBud && !gridItem.isBloomStarted) { affectedBuds.push({ bud: gridItem, gridX: gridX, gridY: gridY }); } } }); // Convert buds to flowers if we have at least 2 and points aren't too old if (affectedBuds.length >= 2) { affectedBuds.forEach(function(budInfo) { budInfo.bud.isBloomStarted = true; // Prevent double-blooming // Remove the bud garden.removeChild(budInfo.bud); // Create new flower var newFlower = new BasicFlower(); newFlower.x = budInfo.bud.x; newFlower.y = budInfo.bud.y; newFlower.isFlower = true; newFlower.scale.set(0.3, 0.3); // Add bloom animation LK.tween(newFlower.scale) .to({x: 1, y: 1}, 1000) .start(); // Add to garden garden.grid[budInfo.gridY][budInfo.gridX] = newFlower; garden.addChild(newFlower); // Create bloom effect self.createBloomEffect(newFlower.x, newFlower.y); if (game.scoreManager) { game.scoreManager.addToChain(); } }); } self.active = false; self.trailPoints = []; }; self.createBloomEffect = function(x, y) { for (var i = 0; i < 12; i++) { var particle = new PollenParticle(); var angle = (i / 12) * Math.PI * 2; var distance = 30; particle.x = x + Math.cos(angle) * distance; particle.y = y + Math.sin(angle) * distance; particle.vx = Math.cos(angle) * 3; particle.vy = Math.sin(angle) * 3; game.addChild(particle); } }; }); // Update PollenParticle to be more visible var PollenParticle = Container.expand(function() { var self = Container.call(this); // Create larger, more visible particle var circle = new Graphics(); circle.beginFill(0xFFFF00, 0.8); circle.drawCircle(0, 0, 8); circle.endFill(); self.addChild(circle); self.lifespan = 60; self.vx = (Math.random() - 0.5) * 2; self.vy = (Math.random() - 0.5) * 2; self.update = function() { self.x += self.vx; self.y += self.vy; self.lifespan--; self.alpha = self.lifespan / 60; // Add slight rotation for more organic feel self.rotation += 0.1; if (self.lifespan <= 0) { self.parent.removeChild(self); } }; });

User prompt

Please fix the bug: 'TypeError: pollenTrail.update is not a function. (In 'pollenTrail.update()', 'pollenTrail.update' is undefined)' in or related to this line: 'pollenTrail.update();' Line Number: 511

User prompt

Please fix the bug: 'Can't find variable: pollenTrail' in or related to this line: 'if (pollenTrail) {' Line Number: 546

User prompt

Please fix the bug: 'Can't find variable: pollenTrail' in or related to this line: 'if (pollenTrail) {' Line Number: 545

User prompt

Update PollenTrail class with this: // Update PollenTrail class to track points and handle blooming var PollenTrail = Container.expand(function() { var self = Container.call(this); self.active = false; self.lastParticleTime = 0; self.trailPoints = []; // Track points for collision detection self.startTrail = function(x, y) { self.active = true; self.trailPoints = [{x: x, y: y}]; self.createParticle(x, y); }; self.updateTrail = function(x, y) { if (!self.active) return; // Add point to trail self.trailPoints.push({x: x, y: y}); // Create particle every few frames var currentTime = LK.ticks; if (currentTime - self.lastParticleTime >= 3) { self.createParticle(x, y); self.lastParticleTime = currentTime; } }; self.createParticle = function(x, y) { var particle = new PollenParticle(); particle.x = x; particle.y = y; game.addChild(particle); }; self.endTrail = function(garden) { if (!self.active) return; // Find all buds affected by the trail var affectedBuds = []; var checkedPositions = {}; // To avoid checking same cell multiple times self.trailPoints.forEach(function(point) { var localPos = garden.toLocal({x: point.x, y: point.y}, game); var gridX = Math.floor(localPos.x / garden.cellSize); var gridY = Math.floor(localPos.y / garden.cellSize); // Create unique key for this grid position var posKey = gridX + ',' + gridY; if (!checkedPositions[posKey] && gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) { checkedPositions[posKey] = true; var gridItem = garden.grid[gridY][gridX]; if (gridItem && gridItem.isBud && !gridItem.isFlower) { affectedBuds.push({ bud: gridItem, gridX: gridX, gridY: gridY }); } } }); // Convert buds to flowers if we have at least 2 if (affectedBuds.length >= 2) { affectedBuds.forEach(function(budInfo, index) { // Remove the bud garden.removeChild(budInfo.bud); // Create new flower var newFlower = new BasicFlower(); newFlower.x = budInfo.bud.x; newFlower.y = budInfo.bud.y; newFlower.isFlower = true; newFlower.scale.set(0.3, 0.3); // Start small // Add bloom animation LK.tween(newFlower.scale) .to({x: 1, y: 1}, 1000) // 1 second bloom animation .start(); // Add to garden garden.grid[budInfo.gridY][budInfo.gridX] = newFlower; garden.addChild(newFlower); // Create bloom particle effect self.createBloomEffect(newFlower.x, newFlower.y); // Update score if we have a score manager if (game.scoreManager) { game.scoreManager.addToChain(); } }); } self.active = false; self.trailPoints = []; }; self.createBloomEffect = function(x, y) { // Create burst of particles for bloom effect for (var i = 0; i < 12; i++) { var particle = new PollenParticle(); 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); } }; }); // Update game.up handler to pass garden reference game.up = function(x, y, obj) { if (pollenTrail && pollenTrail.active) { pollenTrail.endTrail(garden); } };

User prompt

Make pollen particles bigger

User prompt

Remove debug visualization from game down.

User prompt

Please fix the bug: 'Script error.' in or related to this line: 'var marker = new Graphics();' Line Number: 436

User prompt

Update garden class with this: var Garden = Container.expand(function() { var self = Container.call(this); self.grid = []; self.rows = 9; self.cols = 9; self.cellSize = 200; 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 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; } } // Add center flower var centerFlower = new BasicFlower(); var centerRow = Math.floor(self.rows / 2); var centerCol = Math.floor(self.cols / 2); centerFlower.x = centerCol * self.cellSize + self.cellSize / 2; centerFlower.y = centerRow * self.cellSize + self.cellSize / 2; centerFlower.isFlower = true; self.grid[centerRow][centerCol] = centerFlower; self.addChild(centerFlower); }; // 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) }; }; });

User prompt

Update game move with this: game.move = function(x, y, obj) { if (pollenTrail && pollenTrail.active) { pollenTrail.updateTrail(x, y); } };

User prompt

Replace game down with this: game.down = function(x, y, obj) { // Convert global coordinates to garden's local space var localPos = garden.toLocal({x: x, y: y}, game); // Calculate grid position var gridX = Math.floor(localPos.x / garden.cellSize); var gridY = Math.floor(localPos.y / garden.cellSize); // Debug visualization (optional) var marker = new Graphics(); marker.beginFill(0x00FF00); marker.drawCircle(0, 0, 15); marker.endFill(); marker.x = garden.x + (gridX * garden.cellSize) + (garden.cellSize / 2); marker.y = garden.y + (gridY * garden.cellSize) + (garden.cellSize / 2); game.addChild(marker); // Remove marker after 1 second LK.setTimeout(function() { marker.destroy(); }, 1000); if (gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) { var touchedFlower = garden.grid[gridY][gridX]; if (touchedFlower && touchedFlower.isFlower) { pollenTrail.startTrail(x, y); } } };

User prompt

For testing let’s add a Basic Flower asset wherever I touch.

User prompt

Add to game 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(); } } }

User prompt

Debug game logic for creating pollen particles

User prompt

Debug the rendering order of the pollen particles to make sure they are on top

User prompt

Please fix the bug: 'ReferenceError: Can't find variable: tween' in or related to this line: 'tween(bud.scale, {' Line Number: 95 ↪💡 Consider importing and using the following plugins: @upit/tween.v1

User prompt

Debug update loop of pollen particles.

User prompt

Debug positioning of the pollen particles during touch.

User prompt

Debug initialization issues with pollen particle.

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

/**** 
* Classes
****/ 
// BasicFlower class
var BasicFlower = Container.expand(function () {
	var self = Container.call(this);
	var flowerGraphics = self.attachAsset('BasicFlower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Only keep breathing 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;
	};
});
// Bud class
var Bud = Container.expand(function () {
	var self = Container.call(this);
	var budGraphics = self.attachAsset('Bud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Simple periodic animation
	self.update = function () {
		self.rotation = Math.sin(LK.ticks * 0.05) * 0.1;
	};
});
// 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.getSpawnRate = function () {
		if (self.gameTime < 30) {
			// Early game
			return Math.random() * 1000 + 3000; // 3-4s
		} else if (self.gameTime < 90) {
			// Mid game
			return Math.random() * 1000 + 2000; // 2-3s
		} else {
			// Late game
			return Math.random() * 1000 + 1000; // 1-2s
		}
	};
	self.findEmptySpot = function () {
		var validSpots = [];
		for (var i = 0; i < self.garden.rows; i++) {
			for (var j = 0; j < self.garden.cols; j++) {
				if (!self.garden.grid[i][j]) {
					validSpots.push({
						x: i,
						y: j
					});
				}
			}
		}
		if (validSpots.length > 0) {
			return validSpots[Math.floor(Math.random() * validSpots.length)];
		}
		return null;
	};
	self.update = function () {
		self.gameTime = LK.ticks / 60; // Convert ticks to seconds
		if (LK.ticks % Math.floor(self.getSpawnRate() / (1000 / 60)) === 0) {
			var spot = self.findEmptySpot();
			if (spot) {
				var bud = new Bud();
				bud.x = spot.y * self.garden.cellSize + self.garden.cellSize / 2;
				bud.y = spot.x * self.garden.cellSize + self.garden.cellSize / 2;
				bud.isBud = true;
				bud.isFlower = false;
				bud.scale.set(0, 0); // Start invisible for growth animation
				// Add growth animation
				tween(bud.scale, {
					x: 1,
					y: 1
				}, {
					duration: 1000
				});
				self.garden.grid[spot.x][spot.y] = bud;
				self.garden.addChild(bud);
			}
		}
	};
});
// 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);
		return newFlower;
	};
	// Empty touch handler as we're using the new trail system
	self.handleTouch = function () {};
});
//<Assets used in the game will automatically appear here>
// Garden class to manage the grid of soil
var Garden = Container.expand(function () {
	var self = Container.call(this);
	self.grid = [];
	self.rows = 9;
	self.cols = 9;
	self.cellSize = 200;
	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 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;
			}
		}
		// Add center flower
		var centerFlower = new BasicFlower();
		var centerRow = Math.floor(self.rows / 2);
		var centerCol = Math.floor(self.cols / 2);
		centerFlower.x = centerCol * self.cellSize + self.cellSize / 2;
		centerFlower.y = centerRow * self.cellSize + self.cellSize / 2;
		centerFlower.isFlower = true;
		self.grid[centerRow][centerCol] = centerFlower;
		self.addChild(centerFlower);
	};
	// 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);
});
// 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.5 + 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.7 + Math.random() * 0.4); // Even larger for bursts
			self.decayRate = 0.015; // Slower decay for bursts
			// Radial burst velocity
			var angle = Math.random() * Math.PI * 2;
			var speed = 2 + Math.random() * 4;
			self.velocity = {
				x: Math.cos(angle) * speed,
				y: Math.sin(angle) * speed
			};
		}
		// Random rotation speed
		self.rotationSpeed = (Math.random() - 0.5) * 0.2;
		// Random starting rotation
		self.rotation = Math.random() * Math.PI * 2;
		// Full opacity to start
		self.alpha = 1;
		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.startTime = 0;
	self.TRAIL_DURATION = 2500; // 2.5s as specified
	self.MAX_SPEED = 15; // Adjust this value for proper feel
	self.startTrail = function (x, y) {
		self.active = true;
		self.points = [{
			x: x,
			y: y,
			time: Date.now()
		}];
		self.startTime = Date.now();
		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);
	};
	self.endTrail = function (garden) {
		if (!self.active) {
			return;
		}
		// Find affected buds
		var affectedBuds = [];
		var checkedPositions = {};
		self.points.forEach(function (point) {
			var localPos = garden.toLocal({
				x: point.x,
				y: point.y
			}, game);
			var gridX = Math.floor(localPos.x / garden.cellSize);
			var gridY = Math.floor(localPos.y / garden.cellSize);
			var posKey = gridX + ',' + gridY;
			if (!checkedPositions[posKey] && gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) {
				checkedPositions[posKey] = true;
				var gridItem = garden.grid[gridY][gridX];
				if (gridItem && gridItem.isBud && !gridItem.isFlower) {
					affectedBuds.push({
						bud: gridItem,
						gridX: gridX,
						gridY: gridY
					});
				}
			}
		});
		// Convert buds to flowers if we have at least 2
		if (affectedBuds.length >= 2) {
			affectedBuds.forEach(function (budInfo) {
				// Remove the bud
				garden.removeChild(budInfo.bud);
				// Create new flower
				var newFlower = new BasicFlower();
				newFlower.x = budInfo.bud.x;
				newFlower.y = budInfo.bud.y;
				newFlower.isFlower = true;
				newFlower.scale.set(0.3, 0.3);
				// Add bloom animation
				tween(newFlower.scale, {
					x: 1,
					y: 1
				}, {
					duration: 1000
				});
				garden.grid[budInfo.gridY][budInfo.gridX] = newFlower;
				garden.addChild(newFlower);
			});
		}
		self.active = false;
		self.points = [];
	};
	self.update = function () {
		// Remove points older than TRAIL_DURATION
		var currentTime = Date.now();
		self.points = self.points.filter(function (point) {
			return currentTime - point.time < self.TRAIL_DURATION;
		});
		// 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();
		}
	};
});
// 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);
	var garden = new Garden();
	garden.init();
	game.addChild(garden);
	var flowerManager = new FlowerManager();
	game.flowerManager = flowerManager;
	var pollenTrail = new PollenTrail();
	game.addChild(pollenTrail);
	// Ensure pollen particles are rendered on top by adding them last
	game.setChildIndex(pollenTrail, game.children.length - 1);
	// Initialize bud spawner
	var budSpawner = new BudSpawner();
	budSpawner.init(garden);
	game.addChild(budSpawner);
	// Touch handlers
	game.down = function (x, y, obj) {
		// Convert global coordinates to garden's local space
		var localPos = garden.toLocal({
			x: x,
			y: y
		}, game);
		// Calculate grid position
		var gridX = Math.floor(localPos.x / garden.cellSize);
		var gridY = Math.floor(localPos.y / garden.cellSize);
		if (gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) {
			var touchedFlower = garden.grid[gridY][gridX];
			if (touchedFlower && touchedFlower.isFlower) {
				pollenTrail.startTrail(x, y);
			}
		}
	};
	game.move = function (x, y, obj) {
		if (pollenTrail && pollenTrail.active) {
			pollenTrail.updateTrail(x, y);
		}
	};
	game.up = function (x, y, obj) {
		if (pollenTrail && pollenTrail.active) {
			pollenTrail.endTrail(garden);
		}
	};
	// 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 (budSpawner) {
			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();
				}
			}
		}
	};
};
tutorialButton.down = function (x, y, obj) {
	// Open tutorial
};
// Removed duplicate playPollenPatternAnimation method

===================================================================
--- original.js
+++ change.js
@@ -299,12 +299,12 @@
 		// Find affected buds
 		var affectedBuds = [];
 		var checkedPositions = {};
 		self.points.forEach(function (point) {
-			var localPos = self.toLocal({
+			var localPos = garden.toLocal({
 				x: point.x,
 				y: point.y
-			}, garden);
+			}, game);
 			var gridX = Math.floor(localPos.x / garden.cellSize);
 			var gridY = Math.floor(localPos.y / garden.cellSize);
 			var posKey = gridX + ',' + gridY;
 			if (!checkedPositions[posKey] && gridX >= 0 && gridX < garden.cols && gridY >= 0 && gridY < garden.rows) {
@@ -479,9 +479,9 @@
 		}
 	};
 	game.up = function (x, y, obj) {
 		if (pollenTrail && pollenTrail.active) {
-			pollenTrail.endTrail();
+			pollenTrail.endTrail(garden);
 		}
 	};
 	// Initialize score display
 	var scoreDisplay = new ScoreDisplay();

Showing 1701 to 1725 of 2018

1 ...67 68 69 70 71 ...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