/**** 
* 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 = playerBullets.indexOf(self);
					if (index !== -1) {
						playerBullets.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
	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
	});
	// Make boss tougher
	self.health = 10; // Increased boss health for more challenge
	self.speed = 1.5;
	self.scoreValue = 5;
	// Override boss movement pattern
	self.movementPattern = 3; // Special boss pattern
	self.attackCooldown = 0;
	self.shoot = function () {
		var bullet = new BossBullet();
		var bulletGraphics = bullet.attachAsset('bossBullet', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		bulletGraphics.alpha = 1;
		bullet.x = self.x;
		bullet.y = self.y + self.getChildAt(0).height / 2;
		bullet.speed = 10; // Boss bullets move downwards
		game.addChild(bullet);
		bossBullets.push(bullet);
	};
	// Override update method for boss-specific behavior
	var parentUpdate = self.update;
	self.update = function () {
		// Special boss movement: hover at the top area and move 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;
			// Periodically perform special attack (rotate)
			self.attackCooldown--;
			if (self.attackCooldown <= 0) {
				// Start a spin attack
				tween(self.getChildAt(0), {
					rotation: self.getChildAt(0).rotation + Math.PI * 2
				}, {
					duration: 1000,
					easing: tween.easeInOutQuad
				});
				// Reset cooldown
				self.attackCooldown = 300;
				self.shoot(); // Boss shoots when attack cooldown is reset
			}
		}
	};
	// 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 = 5 - self.health;
		self.getChildAt(0).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;
		game.addChild(flashOverlay);
		// Remove the flash overlay
		LK.setTimeout(function () {
			game.removeChild(flashOverlay);
			flashOverlay.destroy();
		}, 100);
		return parentHit.call(self);
	};
	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);
			// 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) {
			for (var i = 0; i < enemyShips.length; i++) {
				if (self.intersects(enemyShips[i])) {
					self.hit();
					enemyShips[i].explode();
					break;
				}
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
/**** 
* Game Variables
****/ 
var playerBullets = [];
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
		} 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;
	// 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
@@ -684,9 +684,8 @@
 };
 // Handle shooting
 game.down = function (x, y, obj) {
 	player.shoot();
-	player.shootCooldown = Math.max(30, player.shootCooldown - 70); // Further increase fire speed by reducing cooldown 
 };
 // Continuous shooting for the player ship
 var shootingInterval = LK.setInterval(function () {
 	player.shoot();