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

/**** 
* Classes
****/ 
var Beehive = Container.expand(function () {
	var self = Container.call(this);
	// Main hive body - preserve dimensions
	self.hiveBody = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.2,
		scaleY: 1.0,
		tint: 0xD8B373 // More honey-like color for beehive
	});
	// Add honeycomb texture effect with layered shapes - preserve proportions
	for (var i = 0; i < 3; i++) {
		var honeyLayer = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.1 - i * 0.1,
			scaleY: 0.9 - i * 0.1,
			alpha: 0.3,
			tint: 0xFFD700 // Gold honey color
		});
	}
	// Hive entrance - preserve proportions
	self.entrance = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -20,
		scaleX: 0.4,
		scaleY: 0.2,
		tint: 0x8B4513 // Brown color for entrance
	});
	// Darker entrance hole - preserve proportions
	self.entranceHole = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -20,
		scaleX: 0.2,
		scaleY: 0.15,
		tint: 0x503000 // Dark entrance hole
	});
	// Hive texture stripes - preserve proportions
	for (var i = 0; i < 5; i++) {
		var stripe = self.attachAsset('beeStripe1', {
			anchorX: 0.5,
			anchorY: 0.5,
			y: -25 + i * 15,
			scaleX: 1.1 - Math.abs(i - 2) * 0.1,
			// Curved effect
			scaleY: 0.15
		});
	}
	// Add some honey drips - preserve proportions
	for (var i = 0; i < 3; i++) {
		var honeyDrip = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.0,
			x: -30 + i * 30,
			y: 30,
			scaleX: 0.1,
			scaleY: 0.2 + Math.random() * 0.15,
			tint: 0xFFD700 // Gold honey color
		});
	}
	// Add some bees hovering near the hive - preserve proportions
	for (var i = 0; i < 3; i++) {
		var hoverBee = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -45 + i * 25,
			y: -30 - i * 8,
			scaleX: 0.15,
			scaleY: 0.08,
			tint: 0xF7DF18
		});
		// Wings for hovering bees - preserve proportions
		var leftWing = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -45 + i * 25 - 4,
			y: -30 - i * 8 - 4,
			scaleX: 0.1,
			scaleY: 0.04,
			tint: 0xFFFFFF,
			alpha: 0.6
		});
		var rightWing = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -45 + i * 25 - 4,
			y: -30 - i * 8 + 4,
			scaleX: 0.1,
			scaleY: 0.04,
			tint: 0xFFFFFF,
			alpha: 0.6
		});
		// Animate wings
		tween(leftWing, {
			rotation: -0.8,
			alpha: 0.8
		}, {
			duration: 100 + i * 10,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
		tween(rightWing, {
			rotation: 0.8,
			alpha: 0.8
		}, {
			duration: 100 + i * 10,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
	}
	self.bees = [];
	self.lastBeeSpawn = 0;
	// Small breathing animation for the hive
	tween(self, {
		y: self.y - 8
	}, {
		duration: 3000,
		easing: tween.easeInOut,
		repeat: -1,
		yoyo: true
	});
	// Add subtle pulsing effect to the hive
	tween(self.hiveBody, {
		scaleX: self.hiveBody.scaleX * 1.03,
		scaleY: self.hiveBody.scaleY * 1.02
	}, {
		duration: 2000,
		easing: tween.easeInOut,
		repeat: -1,
		yoyo: true
	});
	self.update = function () {
		// Bee spawning has been disabled
		// We keep the update method for future functionality
	};
	self.spawnBee = function () {
		var bee = new Insect('bee', 3);
		bee.x = self.x;
		bee.y = self.y - 80;
		game.addChild(bee);
		insects.push(bee);
		// Make the entrance "pulse" when a bee emerges
		tween(self.entrance, {
			scaleX: self.entrance.scaleX * 1.2,
			scaleY: self.entrance.scaleY * 1.2
		}, {
			duration: 200,
			easing: tween.easeOut,
			complete: function complete() {
				tween(self.entrance, {
					scaleX: 1.0,
					scaleY: 0.6
				}, {
					duration: 300,
					easing: tween.easeIn
				});
			}
		});
		// Setup wing tweens for this new bee
		var wingDuration = 500 + Math.random() * 300;
		tween(bee.leftWing, {
			rotation: -1.2,
			scaleX: bee.leftWing.scaleX * 1.2
		}, {
			duration: wingDuration * 0.6,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
		tween(bee.rightWing, {
			rotation: 1.2,
			scaleX: bee.rightWing.scaleX * 1.2
		}, {
			duration: wingDuration * 0.6,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
		// Play buzz sound
		LK.getSound('buzz').play();
		// Add initial flight pattern as bee leaves hive
		tween(bee, {
			x: bee.x + (Math.random() > 0.5 ? 100 : -100),
			y: bee.y - 100
		}, {
			duration: 800,
			easing: tween.easeOut
		});
	};
	return self;
});
var Insect = Container.expand(function (type, speed, beeColor) {
	var self = Container.call(this);
	self.type = type || 'bee';
	self.speed = speed || 3;
	self.vx = Math.random() * self.speed * (Math.random() > 0.5 ? 1 : -1);
	self.vy = Math.random() * self.speed * (Math.random() > 0.5 ? 1 : -1);
	self.lastTrailTime = 0;
	// Only 1/3 of insects will have trails by default
	self.trailActive = false;
	self.hasTrailFeature = Math.random() < 0.33; // Only 33% of insects can have trails
	self.trails = [];
	self.flightOffset = Math.random() * Math.PI * 2; // Random flight pattern offset
	self.flightSpeed = 0.5 + Math.random() * 0.5; // Random flight pattern speed
	self.lastRotation = Math.atan2(self.vy, self.vx);
	self.interactive = true; // Make insect clickable
	if (self.type === 'bee') {
		// Main body
		self.body = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.4,
			scaleY: 0.7,
			tint: beeColor || 0xf7df18 // Use provided bee color or default
		});
		// Bee head
		self.head = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 80,
			scaleX: 0.6,
			scaleY: 0.6
		});
		// Left wing
		self.leftWing = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -25,
			y: -30,
			rotation: -0.7,
			scaleX: 0.8,
			alpha: 0.6,
			tint: 0xffffff
		});
		// Right wing
		self.rightWing = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -25,
			y: 30,
			rotation: 0.7,
			scaleX: 0.8,
			alpha: 0.6,
			tint: 0xffffff
		});
		// Body stripes (reversed direction - vertical instead of horizontal)
		self.stripe1 = self.attachAsset('beeStripe1', {
			anchorX: 0.5,
			anchorY: 0.5,
			rotation: Math.PI / 2,
			x: -25,
			scaleX: 0.7,
			scaleY: 0.8,
			tint: 0x000000
		});
		self.stripe2 = self.attachAsset('beeStripe2', {
			anchorX: 0.5,
			anchorY: 0.5,
			rotation: Math.PI / 2,
			x: 25,
			scaleX: 0.7,
			scaleY: 0.8,
			tint: 0x000000
		});
	} else {
		// Main body
		self.body = self.attachAsset('flyBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.6,
			scaleY: 0.6
		});
		// Fly head
		self.head = self.attachAsset('flyBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 90,
			scaleX: 0.5,
			scaleY: 0.5
		});
		// Left wing
		self.leftWing = self.attachAsset('flyBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -15,
			y: -25,
			rotation: -0.6,
			scaleX: 1.0,
			scaleY: 0.6,
			alpha: 0.6,
			tint: 0xccccff
		});
		// Right wing
		self.rightWing = self.attachAsset('flyBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -15,
			y: 25,
			rotation: 0.6,
			scaleX: 1.0,
			scaleY: 0.6,
			alpha: 0.6,
			tint: 0xccccff
		});
		// Body stripe
		self.stripe1 = self.attachAsset('flyStripe', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.8,
			tint: 0x000000
		});
	}
	self.update = function () {
		// Create more dynamic flight pattern with rapid changes in direction and speed
		var time = LK.ticks * 0.01;
		// Random direction changes based on time
		if (Math.random() < 0.03) {
			// Occasionally make sharp turns
			self.vx += (Math.random() - 0.5) * self.speed * 0.8;
			self.vy += (Math.random() - 0.5) * self.speed * 0.8;
		}
		// Add jerky, insect-like movement with bursts of speed
		var jerkFactor = Math.sin(time * 8) * 0.5; // Higher frequency for more rapid wing beats
		var burstSpeed = Math.random() < 0.01 ? self.speed * 2 : 0; // Occasional speed bursts
		// Normalize velocity for consistent speed
		var currentSpeed = Math.sqrt(self.vx * self.vx + self.vy * self.vy);
		if (currentSpeed > 0) {
			var normalizedVx = self.vx / currentSpeed;
			var normalizedVy = self.vy / currentSpeed;
			// Apply jerk factor and burst speed to create more dynamic movement
			self.x += self.vx + normalizedVx * jerkFactor + normalizedVx * burstSpeed;
			self.y += self.vy + normalizedVy * jerkFactor + normalizedVy * burstSpeed;
		} else {
			// Prevent stalling
			self.vx = (Math.random() - 0.5) * self.speed;
			self.vy = (Math.random() - 0.5) * self.speed;
			self.x += self.vx;
			self.y += self.vy;
		}
		// More energetic bounce off screen edges with slight angle change
		if (self.x < 0 || self.x > 2048) {
			self.vx *= -1.1; // Bounce slightly faster
			// Add slight randomness to bounce angle
			self.vy += (Math.random() - 0.5) * self.speed * 0.5;
			self.x = Math.max(0, Math.min(2048, self.x));
		}
		if (self.y < 0 || self.y > 2732) {
			self.vy *= -1.1; // Bounce slightly faster
			// Add slight randomness to bounce angle
			self.vx += (Math.random() - 0.5) * self.speed * 0.5;
			self.y = Math.max(0, Math.min(2732, self.y));
		}
		// More dynamic rotation with slight overshoot
		var targetRotation = Math.atan2(self.vy, self.vx);
		// Add slight randomness to rotation for more natural movement
		var rotationSpeed = 0.15 + Math.random() * 0.1;
		self.rotation = self.rotation + (targetRotation - self.rotation) * rotationSpeed;
		// Wings are now animated with tweens
		// Just update wing alpha for pulsing effect
		if (self.leftWing && self.rightWing) {
			var wingAlpha = 0.6 + Math.sin(LK.ticks * 0.1) * 0.2;
			self.leftWing.alpha = wingAlpha;
			self.rightWing.alpha = wingAlpha;
		}
		// Create trails when active and insect has the trail feature
		if (self.hasTrailFeature && self.trailActive && LK.ticks % 5 === 0) {
			var dot = LK.getAsset('trailDot', {
				anchorX: 0.5,
				anchorY: 0.5,
				alpha: 0.7,
				tint: 0xFFFFFF // White trail dot color
			});
			dot.x = self.x;
			dot.y = self.y;
			if (self.type === 'bee') {
				dot.tint = 0xFFFFFF; // Always white trail for bees
			} else {
				dot.tint = 0x000000; // Black trail for flies
			}
			// Add dot to the game
			game.addChild(dot);
			// Store reference to dot
			self.trails.push({
				dot: dot,
				createdAt: LK.ticks
			});
		}
		// Remove old trail dots after 10 seconds (previously 2 seconds)
		for (var i = self.trails.length - 1; i >= 0; i--) {
			var trail = self.trails[i];
			if (LK.ticks - trail.createdAt > 600) {
				// Changed from 120 (2 sec) to 600 (10 sec)
				trail.dot.destroy();
				self.trails.splice(i, 1);
			}
		}
	};
	return self;
});
var LevelCompleteMenu = Container.expand(function () {
	var self = Container.call(this);
	// Dark semi-transparent background
	self.bg = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 20,
		scaleY: 20,
		tint: 0x000000,
		alpha: 0.6
	});
	// Menu panel
	self.panel = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 12,
		scaleY: 8,
		tint: 0xFFD700
	});
	// Title text
	self.titleText = new Text2('Level Complete!', {
		size: 120,
		fill: 0x000000
	});
	self.titleText.anchor.set(0.5, 0.5);
	self.titleText.y = -200;
	self.addChild(self.titleText);
	// Level display
	self.levelText = new Text2('Level ' + currentLevel + ' Completed', {
		size: 80,
		fill: 0x000000
	});
	self.levelText.anchor.set(0.5, 0.5);
	self.levelText.y = -80;
	self.addChild(self.levelText);
	// Score display
	self.scoreText = new Text2('Flies Caught: ' + fliesCaught, {
		size: 80,
		fill: 0x000000
	});
	self.scoreText.anchor.set(0.5, 0.5);
	self.scoreText.y = 0;
	self.addChild(self.scoreText);
	// High score display
	var highScore = storage.get('highScore') || 0;
	self.highScoreText = new Text2('High Score: ' + highScore, {
		size: 80,
		fill: 0x000000
	});
	self.highScoreText.anchor.set(0.5, 0.5);
	self.highScoreText.y = 100;
	self.addChild(self.highScoreText);
	// Continue button
	self.continueButton = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 300,
		scaleX: 6,
		scaleY: 2,
		tint: 0x008000
	});
	// Continue button text
	self.continueButtonText = new Text2('Continue', {
		size: 80,
		fill: 0xFFFFFF
	});
	self.continueButtonText.anchor.set(0.5, 0.5);
	self.continueButtonText.y = 300;
	self.addChild(self.continueButtonText);
	// Make button interactive
	self.continueButton.interactive = true;
	self.continueButton.down = function (x, y, obj) {
		self.destroy();
		startNextLevel();
	};
	// Update menu with current level information
	self.updateMenu = function (level, caught) {
		self.levelText.setText('Level ' + level + ' Completed');
		self.scoreText.setText('Flies Caught: ' + caught);
		// Update high score
		var highScore = storage.get('highScore') || 0;
		if (caught > highScore) {
			highScore = caught;
			storage.set('highScore', highScore);
		}
		self.highScoreText.setText('High Score: ' + highScore);
	};
	return self;
});

/**** 
* Initialize Game
****/ 
// Player class removed
var game = new LK.Game({
	backgroundColor: 0x87CEEB // Sky blue background
});

/**** 
* Game Code
****/ 
// Function to start the next level after menu
function startNextLevel() {
	// Generate bee color for this level - first level is yellow, others are random
	var newBeeColor = currentLevel === 1 ? 0xf7df18 : Math.random() * 0xFFFFFF;
	// Update the current level bee color for reference
	currentLevelBeeColor = newBeeColor;
	// Create new flies and bees for the next level
	// Create exactly 30 flies for the next level
	for (var i = 0; i < 30; i++) {
		createInsect('fly');
	}
	// Add some bees as well for variety
	for (var i = 0; i < maxBees; i++) {
		createInsect('bee', null, newBeeColor);
	}
	// Setup wing tweens for all new insects
	setupWingTweens();
}
// Game variables
var insects = [];
var lastTrailToggleTime = 0;
var trailsEnabled = false;
var timeElapsed = 0;
var currentLevel = 1;
var fliesRemaining = 30;
var fliesCaught = 0;
var beeCount = 0;
var maxBees = 10; // Maximum number of bees per level
var currentLevelBeeColor = 0xf7df18; // Initial bee color
// Initialize scoreboard to display flies remaining
var scoreTxt = new Text2('Flies: ' + fliesRemaining, {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Level display
var levelTxt = new Text2('Level: ' + currentLevel, {
	size: 60,
	fill: 0xFFFFFF
});
levelTxt.anchor.set(0.5, 0);
levelTxt.y = 100;
LK.gui.top.addChild(levelTxt);
// Create beehive at the bottom center
var beehive = new Beehive();
beehive.x = 1024; // Center horizontally
beehive.y = 2732 - 120; // Position right at the bottom, maintain height
game.addChild(beehive);
// Create initial 30 flies
for (var i = 0; i < 30; i++) {
	createInsect('fly');
}
// Set first level bees to yellow
currentLevelBeeColor = 0xf7df18; // Yellow color for first level bees
// Add some initial bees
for (var i = 0; i < maxBees; i++) {
	createInsect('bee', null, currentLevelBeeColor);
}
// Set up wing flapping tweens for all insects
function setupWingTweens() {
	for (var i = 0; i < insects.length; i++) {
		var insect = insects[i];
		var wingDuration = 500 + Math.random() * 300; // Random wing flap duration
		// Left wing tween with faster flapping
		tween(insect.leftWing, {
			rotation: -1.2,
			// Wider wing movement
			scaleX: insect.leftWing.scaleX * 1.2 // Wing stretches during flap
		}, {
			duration: wingDuration * 0.6,
			// Faster wing movement
			easing: tween.easeInOut,
			repeat: -1,
			// Continuous flapping
			yoyo: true // Back and forth movement
		});
		// Right wing tween with slight offset
		tween(insect.rightWing, {
			rotation: 1.2,
			// Wider wing movement
			scaleX: insect.rightWing.scaleX * 1.2 // Wing stretches during flap
		}, {
			duration: wingDuration * 0.6,
			// Faster wing movement
			easing: tween.easeInOut,
			repeat: -1,
			// Continuous flapping
			yoyo: true // Back and forth movement
		});
	}
}
// Initialize wing tweens
setupWingTweens();
// Play background music
LK.playMusic('bgmusic');
// Game timer
var gameTimer = LK.setInterval(function () {
	timeElapsed += 1;
	// Toggle trails every 10 seconds
	if (timeElapsed % 10 === 0 && timeElapsed > 0) {
		toggleTrails();
	}
	// Don't automatically create new insects as they're now part of the level system
}, 1000);
// Function to handle level completion
function levelComplete() {
	// Store current level's caught flies for display
	var caughtThisLevel = fliesCaught;
	// Increase level
	currentLevel++;
	levelTxt.setText('Level: ' + currentLevel);
	// Reset flies for next level
	fliesRemaining = 30;
	fliesCaught = 0;
	beeCount = 0;
	scoreTxt.setText('Flies: ' + fliesRemaining);
	// Flash screen to indicate level complete
	LK.effects.flashScreen(0xFFFFFF, 500, 0.5);
	// Remove any remaining insects
	for (var i = insects.length - 1; i >= 0; i--) {
		insects[i].destroy();
	}
	insects = [];
	// Show level complete menu
	LK.setTimeout(function () {
		var menu = new LevelCompleteMenu();
		menu.x = 1024; // Center horizontally
		menu.y = 1366; // Center vertically
		menu.updateMenu(currentLevel - 1, caughtThisLevel);
		game.addChild(menu);
	}, 500);
}
// Function to create a new insect
function createInsect(type, speed, beeColor) {
	// If type is not specified, generate based on context
	// When creating initial level flies, we'll pass 'fly' as the type
	type = type || (Math.random() < 0.7 ? 'fly' : 'bee'); // 70% flies, 30% bees
	speed = speed || 2 + Math.random() * 3; // Random speed between 2-5
	var insect = new Insect(type, speed, beeColor);
	// Position randomly
	insect.x = Math.random() * 2048;
	insect.y = Math.random() * 2000; // Keep away from bottom
	game.addChild(insect);
	insects.push(insect);
	// Setup smooth wing tweens for this insect
	var wingDuration = 500 + Math.random() * 300; // Random wing flap duration
	// Left wing tween with faster flapping
	tween(insect.leftWing, {
		rotation: -1.2,
		// Wider wing movement
		scaleX: insect.leftWing.scaleX * 1.2 // Wing stretches during flap
	}, {
		duration: wingDuration * 0.6,
		// Faster wing movement
		easing: tween.easeInOut,
		repeat: -1,
		// Continuous flapping
		yoyo: true // Back and forth movement
	});
	// Right wing tween with slight offset
	tween(insect.rightWing, {
		rotation: 1.2,
		// Wider wing movement
		scaleX: insect.rightWing.scaleX * 1.2 // Wing stretches during flap
	}, {
		duration: wingDuration * 0.6,
		// Faster wing movement
		easing: tween.easeInOut,
		repeat: -1,
		// Continuous flapping
		yoyo: true // Back and forth movement
	});
	// Add more dynamic body movement
	var bodyBobDuration = 400 + Math.random() * 300; // Faster body movement
	tween(insect, {
		y: insect.y + (Math.random() * 30 - 15),
		// Random up/down movement
		x: insect.x + (Math.random() * 30 - 15),
		// Random left/right movement
		rotation: insect.rotation + (Math.random() * 0.2 - 0.1) // Slight random rotation
	}, {
		duration: bodyBobDuration,
		easing: tween.easeInOut,
		repeat: -1,
		// Infinite repetition
		yoyo: true // Ping-pong effect
	});
	// Make all insects clickable
	insect.down = function (x, y, obj) {
		if (insect.type === 'fly') {
			// Remove the fly when clicked
			insect.destroy();
			// Remove from insects array
			var index = insects.indexOf(insect);
			if (index > -1) {
				insects.splice(index, 1);
			}
			// Update score
			fliesCaught++;
			fliesRemaining--;
			scoreTxt.setText('Flies: ' + fliesRemaining);
			// Play buzz sound
			LK.getSound('buzz').play();
			// Check if level is complete
			if (fliesRemaining <= 0) {
				levelComplete();
			}
		} else if (insect.type === 'bee') {
			// Game over when clicking a bee
			LK.effects.flashScreen(0xFF0000, 1000, 0.7); // Red flash for danger
			LK.getSound('buzz').play();
			LK.setTimeout(function () {
				LK.showGameOver(); // Show game over screen
			}, 500);
		}
	};
	// Play buzz sound on creation
	LK.getSound('buzz').play();
}
// Function to toggle trails on insects that have the trail feature
function toggleTrails() {
	trailsEnabled = !trailsEnabled;
	for (var i = 0; i < insects.length; i++) {
		// Only enable trails on insects that have the trail feature
		if (insects[i].hasTrailFeature) {
			insects[i].trailActive = trailsEnabled;
		}
	}
	if (trailsEnabled) {
		// Flash screen slightly to indicate trails activated
		LK.effects.flashScreen(0xFFFFFF, 300, 0.3);
	}
}
// Helper function to calculate distance between two points
function getDistance(x1, y1, x2, y2) {
	var dx = x2 - x1;
	var dy = y2 - y1;
	return Math.sqrt(dx * dx + dy * dy);
}
// Touch/mouse handlers removed as player is gone
// Main game update function
game.update = function () {
	// Update beehive
	beehive.update();
	// Count how many bees we currently have
	beeCount = 0;
	for (var i = 0; i < insects.length; i++) {
		if (insects[i].type === 'bee') {
			beeCount++;
		}
	}
	// Occasionally add a new bee if we're below the maximum
	if (LK.ticks % 180 === 0 && beeCount < maxBees) {
		// Use the current level's bee color for consistency
		var newBee = new Insect('bee', 3 + Math.random() * 2, currentLevelBeeColor);
		// Position bee near the beehive
		newBee.x = beehive.x + (Math.random() * 200 - 100);
		newBee.y = beehive.y - 100 - Math.random() * 100;
		game.addChild(newBee);
		insects.push(newBee);
		// Setup wing tweens for the new bee
		var wingDuration = 500 + Math.random() * 300;
		tween(newBee.leftWing, {
			rotation: -1.2,
			scaleX: newBee.leftWing.scaleX * 1.2
		}, {
			duration: wingDuration * 0.6,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
		tween(newBee.rightWing, {
			rotation: 1.2,
			scaleX: newBee.rightWing.scaleX * 1.2
		}, {
			duration: wingDuration * 0.6,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
		// Play buzz sound
		LK.getSound('buzz').play();
	}
	// Add slight random movement to insects occasionally
	if (LK.ticks % 60 === 0) {
		for (var i = 0; i < insects.length; i++) {
			var insect = insects[i];
			// Change velocity slightly
			insect.vx += (Math.random() - 0.5) * 2;
			insect.vy += (Math.random() - 0.5) * 2;
			// Limit max speed
			var speed = Math.sqrt(insect.vx * insect.vx + insect.vy * insect.vy);
			if (speed > insect.speed) {
				insect.vx = insect.vx / speed * insect.speed;
				insect.vy = insect.vy / speed * insect.speed;
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -381,16 +381,16 @@
 			var dot = LK.getAsset('trailDot', {
 				anchorX: 0.5,
 				anchorY: 0.5,
 				alpha: 0.7,
-				tint: 0x000000 // Default trail dot color
+				tint: 0xFFFFFF // White trail dot color
 			});
 			dot.x = self.x;
 			dot.y = self.y;
 			if (self.type === 'bee') {
-				dot.tint = self.body.tint !== undefined ? self.body.tint : 0x000000;
+				dot.tint = 0xFFFFFF; // Always white trail for bees
 			} else {
-				dot.tint = 0x000000;
+				dot.tint = 0x000000; // Black trail for flies
 			}
 			// Add dot to the game
 			game.addChild(dot);
 			// Store reference to dot
@@ -454,9 +454,9 @@
 	self.scoreText.anchor.set(0.5, 0.5);
 	self.scoreText.y = 0;
 	self.addChild(self.scoreText);
 	// High score display
-	var highScore = storage.highScore || 0;
+	var highScore = storage.get('highScore') || 0;
 	self.highScoreText = new Text2('High Score: ' + highScore, {
 		size: 80,
 		fill: 0x000000
 	});
@@ -490,12 +490,12 @@
 	self.updateMenu = function (level, caught) {
 		self.levelText.setText('Level ' + level + ' Completed');
 		self.scoreText.setText('Flies Caught: ' + caught);
 		// Update high score
-		var highScore = storage.highScore || 0;
+		var highScore = storage.get('highScore') || 0;
 		if (caught > highScore) {
 			highScore = caught;
-			storage.highScore = highScore;
+			storage.set('highScore', highScore);
 		}
 		self.highScoreText.setText('High Score: ' + highScore);
 	};
 	return self;
@@ -513,10 +513,10 @@
 * Game Code
 ****/ 
 // Function to start the next level after menu
 function startNextLevel() {
-	// Generate random bee color for this level
-	var newBeeColor = Math.random() * 0xFFFFFF;
+	// Generate bee color for this level - first level is yellow, others are random
+	var newBeeColor = currentLevel === 1 ? 0xf7df18 : Math.random() * 0xFFFFFF;
 	// Update the current level bee color for reference
 	currentLevelBeeColor = newBeeColor;
 	// Create new flies and bees for the next level
 	// Create exactly 30 flies for the next level
@@ -564,10 +564,10 @@
 // Create initial 30 flies
 for (var i = 0; i < 30; i++) {
 	createInsect('fly');
 }
-// Set random color for first level bees
-currentLevelBeeColor = Math.random() * 0xFFFFFF;
+// Set first level bees to yellow
+currentLevelBeeColor = 0xf7df18; // Yellow color for first level bees
 // Add some initial bees
 for (var i = 0; i < maxBees; i++) {
 	createInsect('bee', null, currentLevelBeeColor);
 }