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

/**** 
* Classes
****/ 
// Class for boss bullets with proper destruction
var BossBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bossBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bulletGraphics.alpha = 0;
	tween(bulletGraphics, {
		alpha: 1
	}, {
		duration: 100
	});
	self.speed = 10;
	self.update = function () {
		self.y += self.speed;
		if (self.y > 2732 + bulletGraphics.height) {
			tween(bulletGraphics, {
				alpha: 0
			}, {
				duration: 200,
				onFinish: function onFinish() {
					self.destroy();
					var index = bossBullets.indexOf(self);
					if (index !== -1) {
						bossBullets.splice(index, 1);
					}
				}
			});
		}
	};
	return self;
});
// Class for enemy ships with enhanced animation and movement patterns
var EnemyShip = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemyShip', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Enhanced spawn animation: Spiral entry with rotation
	enemyGraphics.scale.set(0);
	enemyGraphics.alpha = 0;
	enemyGraphics.rotation = Math.PI * 2; // Start with a full rotation
	// Sequence of animations for more interesting entry
	tween(enemyGraphics, {
		alpha: 1,
		rotation: 0
	}, {
		duration: 800,
		easing: tween.easeOutQuad
	});
	tween(enemyGraphics.scale, {
		x: 1.2,
		y: 1.2
	}, {
		duration: 600,
		easing: tween.easeOutBack,
		onFinish: function onFinish() {
			tween(enemyGraphics.scale, {
				x: 1,
				y: 1
			}, {
				duration: 300,
				easing: tween.easeInOutQuad
			});
		}
	});
	self.speed = 3 + Math.random() * 2; // Slight variation in speed
	self.driftAmount = 3 + Math.random() * 2; // Enhanced side drift range with randomness
	self.driftSpeed = 50 + Math.random() * 30; // More variation in drift speed
	self.health = 3; // Increase health to 3 for basic enemies
	self.movementPattern = Math.floor(Math.random() * 3); // Random movement pattern (0, 1, or 2)
	self.startX = 0; // Will be set when enemy is added to stage
	self.startTime = LK.ticks; // Remember when enemy was created for time-based patterns
	self.hit = function () {
		self.health -= 1;
		if (self.health <= 0) {
			self.explode();
			return true; // Enemy destroyed
		}
		// Enhanced hit effect: Shake and flash
		var originalX = self.x;
		var shakeTimes = 0;
		var shakeInterval = LK.setInterval(function () {
			self.x = originalX + (Math.random() * 20 - 10);
			shakeTimes++;
			if (shakeTimes >= 5) {
				LK.clearInterval(shakeInterval);
				self.x = originalX;
			}
		}, 50);
		// Flash red then back to normal
		enemyGraphics.tint = 0xFF0000;
		tween(enemyGraphics, {
			alpha: 0.5
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(enemyGraphics, {
					alpha: 1
				}, {
					duration: 100,
					onFinish: function onFinish() {
						enemyGraphics.tint = 0xFFFFFF; // Reset tint
					}
				});
			}
		});
		return false; // Enemy still alive
	};
	self.explode = function () {
		// Create explosion effect before destroying
		var explosion = new Container();
		var explosionGraphics = explosion.attachAsset('explosion', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		explosion.x = self.x;
		explosion.y = self.y;
		explosionGraphics.scale.set(0.1);
		explosionGraphics.alpha = 0.8;
		game.addChild(explosion);
		// Animate explosion
		tween(explosionGraphics.scale, {
			x: 1.5,
			y: 1.5
		}, {
			duration: 500,
			easing: tween.easeOutQuad
		});
		tween(explosionGraphics, {
			alpha: 0
		}, {
			duration: 800,
			onFinish: function onFinish() {
				explosion.destroy();
			}
		});
		// Remove enemy
		self.destroy();
		enemyShips.splice(enemyShips.indexOf(self), 1);
		// Add score
		increaseScore(self.scoreValue || 1);
	};
	self.update = function () {
		var timeSinceSpawn = LK.ticks - self.startTime;
		// Apply different movement patterns based on enemy type
		switch (self.movementPattern) {
			case 0:
				// Standard vertical movement with sine wave drift
				self.y += self.speed;
				self.x = self.startX + Math.sin((LK.ticks - self.startTime) / self.driftSpeed) * self.driftAmount;
				break;
			case 1:
				// Zigzag pattern
				self.y += self.speed;
				self.x = self.startX + Math.sin(LK.ticks / (self.driftSpeed * 0.5)) * self.driftAmount * 10;
				// Rotate ship to match movement direction
				var angleOffset = Math.cos(LK.ticks / (self.driftSpeed * 0.5)) * 0.2;
				enemyGraphics.rotation = angleOffset;
				break;
			case 2:
				// Circular pattern
				self.y += self.speed * 0.7; // Slower vertical movement
				var circleRadius = 50 + Math.random() * 30;
				self.x = self.startX + Math.sin(timeSinceSpawn / (self.driftSpeed * 0.8)) * circleRadius;
				// Add slight rotation for visual effect
				enemyGraphics.rotation = Math.sin(timeSinceSpawn / 500) * 0.1;
				break;
		}
		// Destroy if off-screen with enhanced fade-out effect
		if (self.getChildAt(0).height && self.y > 2732 + self.getChildAt(0).height / 2) {
			tween(enemyGraphics, {
				alpha: 0,
				rotation: Math.PI // Rotate while fading out
			}, {
				duration: 500,
				easing: tween.quadraticIn,
				onFinish: function onFinish() {
					self.destroy();
					var index = enemyShips.indexOf(self);
					if (index !== -1) {
						enemyShips.splice(index, 1);
					}
				}
			});
		}
	};
	return self;
});
// Class for tougher enemy ships with enhanced boss behaviors
var BossEnemy = EnemyShip.expand(function () {
	var self = EnemyShip.call(this);
	self.getChildAt(0).destroy(); // Remove the default enemy ship graphic
	var bossGraphics = self.attachAsset('bossShip', {
		// Attach new boss ship graphic
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Make boss larger with pulsing effect
	self.getChildAt(0).scale.set(0);
	// More impressive boss entrance
	tween(self.getChildAt(0).scale, {
		x: 1.8,
		y: 1.8
	}, {
		duration: 1200,
		easing: tween.easeOutElastic
	});
	// Pulsing effect for the boss
	LK.setInterval(function () {
		tween(bossGraphics, {
			alpha: 0.7
		}, {
			duration: 400,
			onFinish: function onFinish() {
				tween(bossGraphics, {
					alpha: 1
				}, {
					duration: 400
				});
			}
		});
	}, 1000);
	// Make boss tougher
	self.health = 20; // Further increased boss health for more challenge
	self.maxHealth = 20; // Store max health for phase transitions
	self.speed = 1.5;
	self.scoreValue = 10; // Increased score value
	self.phase = 1; // Boss has multiple phases
	self.movementPattern = 3; // Special boss pattern
	self.attackCooldown = 0;
	self.attackType = 0; // Different attack types
	// Boss attack patterns
	self.shoot = function () {
		// Different attack patterns based on boss phase
		switch (self.attackType) {
			case 0:
				// Single shot
				var bullet = new BossBullet();
				bullet.x = self.x;
				bullet.y = self.y + self.getChildAt(0).height / 2;
				bullet.speed = 10;
				game.addChild(bullet);
				bossBullets.push(bullet);
				break;
			case 1:
				// Triple shot spread
				for (var i = -1; i <= 1; i++) {
					var bullet = new BossBullet();
					bullet.x = self.x + i * 50;
					bullet.y = self.y + self.getChildAt(0).height / 2;
					bullet.speed = 8;
					game.addChild(bullet);
					bossBullets.push(bullet);
				}
				break;
			case 2:
				// Circle shot
				var bulletCount = 8;
				for (var i = 0; i < bulletCount; i++) {
					var angle = Math.PI * 2 / bulletCount * i;
					var bullet = new BossBullet();
					bullet.x = self.x;
					bullet.y = self.y;
					// Initial position adjustment for circle pattern
					bullet.x += Math.cos(angle) * 70;
					bullet.y += Math.sin(angle) * 70;
					// Custom update for circular bullets
					var originalUpdate = bullet.update;
					bullet.angle = angle;
					bullet.update = function () {
						this.x += Math.cos(this.angle) * 5;
						this.y += Math.sin(this.angle) * 5;
						// Call original update for off-screen checks
						originalUpdate.call(this);
					};
					game.addChild(bullet);
					bossBullets.push(bullet);
				}
				break;
		}
		// Visual effect for shooting
		var flash = new Container();
		var flashGraphics = flash.attachAsset('flash', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		flash.x = self.x;
		flash.y = self.y + self.getChildAt(0).height / 3;
		flash.scale.set(2);
		game.addChild(flash);
		tween(flash, {
			alpha: 0,
			scale: 3
		}, {
			duration: 300,
			onFinish: function onFinish() {
				flash.destroy();
			}
		});
	};
	// Override update method for boss-specific behavior
	var parentUpdate = self.update;
	self.update = function () {
		// Update phase based on health percentage
		var healthPercent = self.health / self.maxHealth;
		if (healthPercent < 0.65 && self.phase === 1) {
			self.transitionToPhase(2);
		} else if (healthPercent < 0.3 && self.phase === 2) {
			self.transitionToPhase(3);
		}
		// Phase-specific movement patterns
		switch (self.phase) {
			case 1:
				// Phase 1: Hover at top, side to side
				if (self.y < 400) {
					self.y += self.speed;
				} else {
					// Wide side-to-side movement
					self.x = 2048 / 2 + Math.sin(LK.ticks / 100) * 800;
					// Attack cooldown
					self.attackCooldown--;
					if (self.attackCooldown <= 0) {
						self.attackType = 0; // Single shot in phase 1
						self.shoot();
						self.attackCooldown = 120; // Faster attacks in phase 1
					}
				}
				break;
			case 2:
				// Phase 2: Aggressive movement, triple shots
				// Figure-8 movement pattern
				var t = LK.ticks / 150;
				self.x = 2048 / 2 + Math.sin(t) * 600;
				self.y = 500 + Math.sin(t * 2) * 200;
				// Boss slightly tilts in direction of movement
				var dx = Math.cos(t) * 600;
				var tilt = dx * 0.0001;
				bossGraphics.rotation = tilt;
				// Attack cooldown
				self.attackCooldown--;
				if (self.attackCooldown <= 0) {
					self.attackType = 1; // Triple shot in phase 2
					self.shoot();
					self.attackCooldown = 100;
				}
				break;
			case 3:
				// Phase 3: Erratic movement, circle shots
				// Erratic movement
				var t = LK.ticks / 100;
				self.x = 2048 / 2 + Math.sin(t) * 500 + Math.cos(t * 2.5) * 300;
				self.y = 500 + Math.sin(t * 1.5) * 300;
				// Dramatic rotation
				bossGraphics.rotation = Math.sin(t) * 0.2;
				// Attack cooldown - mix of attack types
				self.attackCooldown--;
				if (self.attackCooldown <= 0) {
					// Alternate between triple and circle shots
					self.attackType = LK.ticks % 300 < 150 ? 1 : 2;
					self.shoot();
					self.attackCooldown = 80; // Even faster attacks in final phase
				}
				break;
		}
	};
	// Phase transition effects
	self.transitionToPhase = function (newPhase) {
		self.phase = newPhase;
		// Visual effect for phase transition
		bossGraphics.tint = 0xFF0000;
		// Dramatic shake effect
		var originalX = self.x;
		var originalY = self.y;
		var shakeAmount = 30;
		var shakeTimes = 0;
		var shakeInterval = LK.setInterval(function () {
			self.x = originalX + (Math.random() * shakeAmount - shakeAmount / 2);
			self.y = originalY + (Math.random() * shakeAmount - shakeAmount / 2);
			shakeAmount *= 0.8;
			shakeTimes++;
			if (shakeTimes >= 12) {
				LK.clearInterval(shakeInterval);
				self.x = originalX;
				self.y = originalY;
				// Reset tint after shake
				tween(bossGraphics, {
					tint: 0xFFFFFF
				}, {
					duration: 500
				});
			}
		}, 50);
		// Phase transition announcement
		var phaseText = new Text2('PHASE ' + newPhase, {
			size: 200,
			fill: 0xFF0000
		});
		phaseText.anchor.set(0.5, 0.5);
		phaseText.x = 2048 / 2;
		phaseText.y = 2732 / 2;
		phaseText.alpha = 0;
		game.addChild(phaseText);
		// Animate phase text
		tween(phaseText, {
			alpha: 1
		}, {
			duration: 300,
			onFinish: function onFinish() {
				tween(phaseText, {
					alpha: 0,
					y: phaseText.y - 100
				}, {
					duration: 700,
					delay: 500,
					onFinish: function onFinish() {
						phaseText.destroy();
					}
				});
			}
		});
		// Create surrounding explosions for dramatic effect
		for (var i = 0; i < 8; i++) {
			var delay = i * 100;
			LK.setTimeout(function () {
				var explosion = new Container();
				var explosionGraphics = explosion.attachAsset('explosion', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				var angle = Math.random() * Math.PI * 2;
				var distance = 150 + Math.random() * 150;
				explosion.x = self.x + Math.cos(angle) * distance;
				explosion.y = self.y + Math.sin(angle) * distance;
				explosionGraphics.scale.set(0.5);
				game.addChild(explosion);
				tween(explosionGraphics.scale, {
					x: 1.5,
					y: 1.5
				}, {
					duration: 500
				});
				tween(explosionGraphics, {
					alpha: 0
				}, {
					duration: 800,
					onFinish: function onFinish() {
						explosion.destroy();
					}
				});
			}, delay);
		}
	};
	// Override hit method for boss-specific effect
	var parentHit = self.hit;
	self.hit = function () {
		// Flash the boss with a different color on each hit
		var hitColors = [0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0xFF00FF];
		var colorIndex = Math.floor(Math.random() * hitColors.length);
		bossGraphics.tint = hitColors[colorIndex];
		// Flash the screen slightly
		var flashOverlay = new Container();
		var flashGraphics = flashOverlay.attachAsset('flash', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		flashOverlay.x = 2048 / 2;
		flashOverlay.y = 2732 / 2;
		flashOverlay.scale.set(3);
		flashOverlay.alpha = 0.3;
		game.addChild(flashOverlay);
		// Remove the flash overlay
		LK.setTimeout(function () {
			game.removeChild(flashOverlay);
			flashOverlay.destroy();
		}, 100);
		// Reset tint after a short delay
		LK.setTimeout(function () {
			bossGraphics.tint = 0xFFFFFF;
		}, 200);
		return parentHit.call(self);
	};
	// Enhanced explode method for epic boss death
	var parentExplode = self.explode;
	self.explode = function () {
		// Create multiple explosions in sequence
		var explosionCount = 20;
		var interval = LK.setInterval(function () {
			var explosion = new Container();
			var explosionGraphics = explosion.attachAsset('explosion', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			explosion.x = self.x + (Math.random() * 200 - 100);
			explosion.y = self.y + (Math.random() * 200 - 100);
			var randomScale = 0.5 + Math.random() * 1.5;
			explosionGraphics.scale.set(randomScale);
			game.addChild(explosion);
			tween(explosionGraphics, {
				alpha: 0
			}, {
				duration: 1000,
				onFinish: function onFinish() {
					explosion.destroy();
				}
			});
			explosionCount--;
			if (explosionCount <= 0) {
				LK.clearInterval(interval);
				// Add special reward text
				var victoryText = new Text2('BOSS DEFEATED!', {
					size: 250,
					fill: 0xFFD700 // Gold color
				});
				victoryText.anchor.set(0.5, 0.5);
				victoryText.x = 2048 / 2;
				victoryText.y = 2732 / 2;
				victoryText.alpha = 0;
				game.addChild(victoryText);
				tween(victoryText, {
					alpha: 1,
					y: victoryText.y - 50
				}, {
					duration: 800,
					easing: tween.easeOutElastic,
					onFinish: function onFinish() {
						LK.setTimeout(function () {
							tween(victoryText, {
								alpha: 0,
								y: victoryText.y - 100
							}, {
								duration: 1000,
								onFinish: function onFinish() {
									victoryText.destroy();
								}
							});
						}, 1500);
					}
				});
				// Finally call parent explode to remove boss and add score
				parentExplode.call(self);
				// Add bonus score for defeating boss
				increaseScore(20);
			}
		}, 150);
	};
	return self;
});
// Class for player bullets with proper destruction
var PlayerBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('playerBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Enhanced bullet appearance
	bulletGraphics.alpha = 0;
	tween(bulletGraphics, {
		alpha: 1
	}, {
		duration: 100
	});
	self.speed = -15;
	self.update = function () {
		self.y += self.speed;
		// Add slight wobble to bullets
		self.x += Math.sin(LK.ticks / 10) * 0.5;
		if (self.y < -bulletGraphics.height) {
			// Fade out bullets that miss
			tween(bulletGraphics, {
				alpha: 0
			}, {
				duration: 200,
				onFinish: function onFinish() {
					self.destroy();
					var index = playerBullets.indexOf(self);
					if (index !== -1) {
						playerBullets.splice(index, 1);
					}
				}
			});
		}
	};
	return self;
});
// Class for the player's ship with enhanced movement and effects
var PlayerShip = Container.expand(function () {
	var self = Container.call(this);
	var shipGraphics = self.attachAsset('playerShip', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 10;
	self.canShoot = true; // Prevents spam shooting
	self.shootCooldown = 150; // Reduced cooldown for faster shooting
	self.lives = 3; // Player starts with 3 lives
	self.invulnerable = false; // Invulnerability after being hit
	self.targetX = null; // Target X position for smooth movement
	self.targetY = null; // Target Y position for smooth movement
	// Player ship entrance animation
	shipGraphics.alpha = 0;
	shipGraphics.y = 100;
	tween(shipGraphics, {
		alpha: 1,
		y: 0
	}, {
		duration: 1000,
		easing: tween.easeOutQuad
	});
	self.shoot = function () {
		if (self.canShoot) {
			var bullet = new PlayerBullet();
			bullet.x = self.x;
			bullet.y = self.y - shipGraphics.height / 2;
			game.addChild(bullet);
			playerBullets.push(bullet);
			// Play shooting sound effect
			LK.getSound('shoot').play();
			// Add muzzle flash effect
			var flash = new Container();
			var flashGraphics = flash.attachAsset('flash', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			flash.x = self.x;
			flash.y = self.y - shipGraphics.height / 2;
			game.addChild(flash);
			// Animate and remove flash
			tween(flash.scale, {
				x: 0,
				y: 0
			}, {
				duration: 200,
				onFinish: function onFinish() {
					flash.destroy();
				}
			});
			// Add slight recoil effect
			tween(shipGraphics, {
				y: 5
			}, {
				duration: 50,
				onFinish: function onFinish() {
					tween(shipGraphics, {
						y: 0
					}, {
						duration: 100
					});
				}
			});
			self.canShoot = false;
			LK.setTimeout(function () {
				self.canShoot = true;
			}, self.shootCooldown);
		}
	};
	self.hit = function () {
		if (self.invulnerable) {
			return;
		}
		self.lives--;
		updateLivesDisplay();
		if (self.lives <= 0) {
			// Add dramatic death animation
			var explosions = 5;
			var explodeInterval = LK.setInterval(function () {
				var explosion = new Container();
				var explosionGraphics = explosion.attachAsset('explosion', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				explosion.x = self.x + (Math.random() * 100 - 50);
				explosion.y = self.y + (Math.random() * 100 - 50);
				explosionGraphics.scale.set(0.1);
				explosionGraphics.alpha = 0.8;
				game.addChild(explosion);
				tween(explosionGraphics.scale, {
					x: 1,
					y: 1
				}, {
					duration: 500
				});
				tween(explosionGraphics, {
					alpha: 0
				}, {
					duration: 800,
					onFinish: function onFinish() {
						explosion.destroy();
					}
				});
				explosions--;
				if (explosions <= 0) {
					LK.clearInterval(explodeInterval);
					self.visible = false;
					LK.showGameOver();
				}
			}, 150);
			return;
		}
		// Make player invulnerable temporarily
		self.invulnerable = true;
		// Enhanced hit effect with shake
		var originalX = self.x;
		var shakeAmount = 15;
		var shakeTimes = 0;
		var shakeInterval = LK.setInterval(function () {
			self.x = originalX + (Math.random() * shakeAmount - shakeAmount / 2);
			shakeAmount *= 0.9;
			shakeTimes++;
			if (shakeTimes >= 10) {
				LK.clearInterval(shakeInterval);
				self.x = originalX;
			}
		}, 50);
		// Flash effect
		var flashCount = 0;
		var flashInterval = LK.setInterval(function () {
			shipGraphics.alpha = shipGraphics.alpha === 1 ? 0.3 : 1;
			flashCount++;
			if (flashCount >= 10) {
				LK.clearInterval(flashInterval);
				shipGraphics.alpha = 1;
				self.invulnerable = false;
			}
		}, 150);
	};
	// Move player ship to target position with smooth animation
	self.moveToPosition = function (x, y) {
		self.targetX = x;
		self.targetY = y;
	};
	self.update = function () {
		// Smooth movement toward target position
		if (self.targetX !== null && self.targetY !== null) {
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			// Only move if the distance is significant
			if (Math.abs(dx) > 1 || Math.abs(dy) > 1) {
				self.x += dx * 0.1;
				self.y += dy * 0.1;
				// Slight tilt effect based on horizontal movement
				var tiltAmount = -dx * 0.0005;
				tiltAmount = Math.max(-0.2, Math.min(0.2, tiltAmount));
				shipGraphics.rotation = tiltAmount;
			} else {
				// Reached target, reset rotation
				shipGraphics.rotation = 0;
			}
		}
		// Check for collisions with enemies if not invulnerable
		if (!self.invulnerable) {
			// Check for collisions with enemy ships
			for (var i = 0; i < enemyShips.length; i++) {
				if (self.intersects(enemyShips[i])) {
					self.hit();
					enemyShips[i].explode();
					break;
				}
			}
			// Check for collisions with power-ups
			for (var i = 0; i < powerUps.length; i++) {
				if (self.intersects(powerUps[i])) {
					if (powerUps[i].type === 'fireRate') {
						self.shootCooldown = 75; // Increase fire rate
						LK.setTimeout(function () {
							self.shootCooldown = 150; // Reset fire rate after 10 seconds
						}, 10000);
					}
					powerUps[i].destroy();
					powerUps.splice(i, 1);
				}
			}
			// Check collisions with boss bullets
			for (var j = 0; j < bossBullets.length; j++) {
				if (bossBullets[j] && self.intersects(bossBullets[j])) {
					self.hit();
					// Remove the bullet
					bossBullets[j].destroy();
					bossBullets.splice(j, 1);
					break;
				}
			}
		}
	};
	return self;
});
// Class for power-up items
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var powerUpGraphics = self.attachAsset('powerUp', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = 'fireRate'; // Type of power-up
	self.update = function () {
		self.y += 5; // Move power-up downwards
		if (self.y > 2732 + powerUpGraphics.height) {
			self.destroy();
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
var background = LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2
});
game.addChild(background);
/**** 
* Game Variables
****/ 
var playerBullets = [];
var powerUps = [];
var bossBullets = [];
var enemyShips = [];
var player = game.addChild(new PlayerShip());
player.x = 2048 / 2;
player.y = 2732 - 200;
// Score Display
var scoreText = new Text2('0', {
	size: 150,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
scoreText.x = 2048 / 2;
scoreText.y = 50;
LK.gui.top.addChild(scoreText);
// Lives Display
var livesText = new Text2('Lives: 3', {
	size: 100,
	fill: 0xFFFFFF
});
livesText.anchor.set(0, 0);
livesText.x = 50;
livesText.y = 50;
LK.gui.top.addChild(livesText);
// Wave Display
var waveText = new Text2('Wave: 1', {
	size: 100,
	fill: 0xFFFFFF
});
waveText.anchor.set(1, 0);
waveText.x = 2048 - 50;
waveText.y = 50;
LK.gui.top.addChild(waveText);
// Wave Variables
var waveNumber = 1;
var enemiesPerWave = 5;
var enemiesSpawned = 0;
var waveInProgress = true;
var waveCooldown = false;
// Helper Functions
function updateLivesDisplay() {
	livesText.setText('Lives: ' + player.lives);
}
function increaseScore(amount) {
	LK.setScore(LK.getScore() + amount);
	scoreText.setText(LK.getScore());
}
function updateWaveDisplay() {
	waveText.setText('Wave: ' + waveNumber);
}
// Function to spawn enemies in waves with enhanced patterns
function spawnEnemy() {
	if (!waveInProgress || waveCooldown) {
		return;
	}
	if (enemiesSpawned < enemiesPerWave) {
		var enemy;
		// Every 3 waves, add a boss
		if (waveNumber > 0 && waveNumber % 3 === 0 && enemiesSpawned === enemiesPerWave - 1) {
			enemy = new BossEnemy();
			enemy.x = 2048 / 2; // Boss appears in center
			// Spawn power-up during boss fight
			var powerUp = new PowerUp();
			powerUp.x = 2048 / 2;
			powerUp.y = -100;
			game.addChild(powerUp);
			powerUps.push(powerUp);
		} else {
			enemy = new EnemyShip();
			enemy.x = 200 + Math.random() * (2048 - 400); // Random position, avoiding edges
		}
		enemy.startX = enemy.x; // Store starting X for movement patterns
		enemy.y = -100;
		game.addChild(enemy);
		enemyShips.push(enemy);
		enemiesSpawned++;
		if (enemiesSpawned >= enemiesPerWave) {
			waveInProgress = false;
		}
	}
}
function startNextWave() {
	waveNumber++;
	updateWaveDisplay();
	enemiesPerWave += 2; // Increase difficulty each wave
	enemiesSpawned = 0;
	waveInProgress = true;
	// Change background after each wave
	var backgroundId = 'background';
	if (waveNumber % 3 === 1) {
		backgroundId = 'background2';
	} else if (waveNumber % 3 === 2) {
		backgroundId = 'background3';
	} else if (waveNumber % 3 === 0) {
		backgroundId = 'background4';
	}
	background.destroy();
	background = LK.getAsset(backgroundId, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048 / 2,
		y: 2732 / 2
	});
	game.addChildAt(background, 0);
	// Enhanced wave announcement with scaling and color
	var newWaveText = new Text2('WAVE ' + waveNumber, {
		size: 250,
		fill: 0x00FFFF
	});
	newWaveText.anchor.set(0.5, 0.5);
	newWaveText.x = 2048 / 2;
	newWaveText.y = 2732 / 2;
	newWaveText.scale.set(0.5);
	game.addChild(newWaveText);
	// Animate and remove wave text
	tween(newWaveText.scale, {
		x: 1.8,
		y: 1.8
	}, {
		duration: 800,
		easing: tween.easeOutElastic,
		onFinish: function onFinish() {
			tween(newWaveText, {
				alpha: 0,
				y: newWaveText.y - 100
			}, {
				duration: 500,
				easing: tween.easeInQuad,
				onFinish: function onFinish() {
					newWaveText.destroy();
				}
			});
		}
	});
}
// Game update loop
game.update = function () {
	// Update player
	player.update();
	// Update player bullets
	for (var i = playerBullets.length - 1; i >= 0; i--) {
		if (playerBullets[i]) {
			playerBullets[i].update();
		}
	}
	// Update boss bullets
	for (var i = bossBullets.length - 1; i >= 0; i--) {
		if (bossBullets[i]) {
			bossBullets[i].update();
		}
	}
	for (var j = enemyShips.length - 1; j >= 0; j--) {
		if (enemyShips[j]) {
			enemyShips[j].update();
		}
	}
	// Check for collisions between player bullets and enemy ships
	for (var k = playerBullets.length - 1; k >= 0; k--) {
		if (!playerBullets[k]) {
			continue;
		}
		for (var l = enemyShips.length - 1; l >= 0; l--) {
			if (!enemyShips[l]) {
				continue;
			}
			if (playerBullets[k] && enemyShips[l] && playerBullets[k].intersects(enemyShips[l])) {
				// Enemy hit by bullet
				var destroyed = enemyShips[l].hit();
				// Remove bullet
				playerBullets[k].destroy();
				playerBullets.splice(k, 1);
				break;
			}
		}
	}
	// Spawn enemies periodically
	if (LK.ticks % 60 === 0) {
		spawnEnemy();
	}
	// Check if wave is complete and start next wave
	if (!waveInProgress && enemyShips.length === 0 && !waveCooldown) {
		waveCooldown = true;
		LK.setTimeout(function () {
			startNextWave();
			waveCooldown = false;
		}, 2000);
	}
};
// Handle player movement - Update to allow free movement
game.move = function (x, y, obj) {
	// Set target position for smooth movement anywhere on screen
	player.moveToPosition(x, y);
};
// Handle shooting
game.down = function (x, y, obj) {
	player.shoot();
};
// Continuous shooting for the player ship
var shootingInterval = LK.setInterval(function () {
	player.shoot();
}, 150); // Match the reduced cooldown

===================================================================
--- original.js
+++ change.js
@@ -575,9 +575,21 @@
 		self.y += self.speed;
 		// Add slight wobble to bullets
 		self.x += Math.sin(LK.ticks / 10) * 0.5;
 		if (self.y < -bulletGraphics.height) {
-			returnBullet(self); // Return bullet to the pool if it goes off-screen
+			// Fade out bullets that miss
+			tween(bulletGraphics, {
+				alpha: 0
+			}, {
+				duration: 200,
+				onFinish: function onFinish() {
+					self.destroy();
+					var index = playerBullets.indexOf(self);
+					if (index !== -1) {
+						playerBullets.splice(index, 1);
+					}
+				}
+			});
 		}
 	};
 	return self;
 });
@@ -604,24 +616,11 @@
 	}, {
 		duration: 1000,
 		easing: tween.easeOutQuad
 	});
-	// Bullet Pooling Implementation
-	var bulletPool = []; // Array to hold bullet objects
-	function getBullet() {
-		if (bulletPool.length > 0) {
-			return bulletPool.pop(); // Reuse a bullet from the pool
-		}
-		return new PlayerBullet(); // Create a new bullet if pool is empty
-	}
-	function returnBullet(bullet) {
-		bullet.destroy(); // Clean up the bullet
-		bulletPool.push(bullet); // Return it to the pool
-	}
-	// Modify the PlayerShip shoot method to use the bullet pool
 	self.shoot = function () {
 		if (self.canShoot) {
-			var bullet = getBullet(); // Get a bullet from the pool
+			var bullet = new PlayerBullet();
 			bullet.x = self.x;
 			bullet.y = self.y - shipGraphics.height / 2;
 			game.addChild(bullet);
 			playerBullets.push(bullet);
@@ -821,13 +820,8 @@
 
 /**** 
 * Game Code
 ****/ 
-// Function to return a bullet to the pool
-function returnBullet(bullet) {
-	bullet.destroy(); // Clean up the bullet
-	bulletPool.push(bullet); // Return it to the pool
-}
 var background = LK.getAsset('background', {
 	anchorX: 0.5,
 	anchorY: 0.5,
 	x: 2048 / 2,
@@ -836,9 +830,8 @@
 game.addChild(background);
 /**** 
 * Game Variables
 ****/ 
-var bulletPool = []; // Array to hold bullet objects
 var playerBullets = [];
 var powerUps = [];
 var bossBullets = [];
 var enemyShips = [];