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

/**** 
* Classes
****/ 
var Airship = Container.expand(function () {
	var self = Container.call(this);
	// Main body
	var bodyGraphics = self.attachAsset('airshipBody', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Shield
	var shieldGraphics = self.attachAsset('airshipShield', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.5
	});
	// Core (initially hidden)
	var coreGraphics = self.attachAsset('airshipCore', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	self.maxHealth = 1000;
	self.health = self.maxHealth;
	self.shieldActive = true;
	self.phase = 1;
	self.turrets = [];
	self.movementPhase = 0;
	self.movementTimer = 0;
	self.targetX = 0;
	self.targetY = 0;
	// Initialize turrets
	self.initTurrets = function () {
		// Create 6 turrets positioned around the airship
		var turretPositions = [{
			x: -250,
			y: -80
		},
		// left front
		{
			x: 250,
			y: -80
		},
		// right front
		{
			x: -150,
			y: 0
		},
		// left middle
		{
			x: 150,
			y: 0
		},
		// right middle
		{
			x: -200,
			y: 80
		},
		// left rear
		{
			x: 200,
			y: 80
		} // right rear
		];
		for (var i = 0; i < turretPositions.length; i++) {
			var turret = new AirshipTurret();
			turret.offsetX = turretPositions[i].x;
			turret.offsetY = turretPositions[i].y;
			turret.parentAirship = self;
			turret.x = self.x + turret.offsetX;
			turret.y = self.y + turret.offsetY;
			self.turrets.push(turret);
			game.addChild(turret);
			allTurrets.push(turret);
		}
	};
	self.update = function () {
		// Movement pattern
		self.updateMovement();
		// Check if we need to transition to the next phase
		self.checkPhaseTransition();
	};
	self.updateMovement = function () {
		self.movementTimer++;
		switch (self.phase) {
			case 1:
				// Phase 1: Simple left-right movement
				if (self.movementTimer > 180) {
					// Change direction every 3 seconds
					self.movementTimer = 0;
					self.targetX = 600 + Math.random() * 848; // Random position in middle portion
				}
				// Move toward target
				self.x += (self.targetX - self.x) * 0.02;
				break;
			case 2:
				// Phase 2: More aggressive movement
				if (self.movementTimer > 120) {
					// Change direction every 2 seconds
					self.movementTimer = 0;
					self.targetX = 400 + Math.random() * 1248; // Wider range
					self.targetY = 200 + Math.random() * 100; // Small vertical movement
				}
				// Move toward target
				self.x += (self.targetX - self.x) * 0.03;
				self.y += (self.targetY - self.y) * 0.02;
				break;
			case 3:
				// Phase 3: Erratic movement
				if (self.movementTimer > 90) {
					// Change direction every 1.5 seconds
					self.movementTimer = 0;
					self.targetX = 300 + Math.random() * 1448; // Full width movement
					self.targetY = 150 + Math.random() * 200; // More vertical movement
				}
				// Move toward target
				self.x += (self.targetX - self.x) * 0.04;
				self.y += (self.targetY - self.y) * 0.03;
				break;
		}
	};
	self.checkPhaseTransition = function () {
		var healthPercent = self.health / self.maxHealth;
		// Phase transitions
		if (healthPercent <= 0.66 && self.phase === 1) {
			self.transitionToPhase(2);
		} else if (healthPercent <= 0.33 && self.phase === 2) {
			self.transitionToPhase(3);
		}
	};
	self.transitionToPhase = function (newPhase) {
		self.phase = newPhase;
		if (newPhase === 2) {
			// Disable shield
			self.shieldActive = false;
			shieldGraphics.alpha = 0;
			LK.getSound('shieldDown').play();
			// Flash the core briefly
			tween(coreGraphics, {
				alpha: 0.8
			}, {
				duration: 1000,
				onFinish: function onFinish() {
					tween(coreGraphics, {
						alpha: 0.3
					}, {
						duration: 500
					});
				}
			});
		} else if (newPhase === 3) {
			// Core fully exposed
			tween(coreGraphics, {
				alpha: 1
			}, {
				duration: 1000
			});
			// Flash the screen
			LK.effects.flashScreen(0xffffff, 500);
		}
	};
	self.takeDamage = function (damage, isCoreHit) {
		// If shield is active, only take 20% damage
		if (self.shieldActive && !isCoreHit) {
			damage = Math.floor(damage * 0.2);
			LK.effects.flashObject(shieldGraphics, 0xaaaaff, 300);
		}
		// Core hits do double damage
		if (isCoreHit && self.phase >= 2) {
			damage *= 2;
			LK.effects.flashObject(coreGraphics, 0xffff00, 300);
		}
		self.health -= damage;
		// Update health bar
		updateHealthBar(self.health, self.maxHealth);
		if (self.health <= 0) {
			self.explode();
			return true;
		}
		return false;
	};
	self.explode = function () {
		// Create multiple explosions
		var explosionCount = 20;
		// Create a sequence of explosions
		function createExplosionSequence(i) {
			if (i >= explosionCount) {
				// Final explosion and game win
				LK.effects.flashScreen(0xffffff, 1000);
				LK.setTimeout(function () {
					LK.showYouWin();
				}, 1500);
				return;
			}
			var explosion = new Explosion();
			explosion.x = self.x + (Math.random() * 500 - 250);
			explosion.y = self.y + (Math.random() * 250 - 125);
			explosion.scale.set(1.5 + Math.random() * 2);
			game.addChild(explosion);
			explosions.push(explosion);
			LK.getSound('explosion').play();
			// Schedule next explosion
			LK.setTimeout(function () {
				createExplosionSequence(i + 1);
			}, 100);
		}
		// Start the explosion sequence
		createExplosionSequence(0);
	};
	self.isCoreHit = function (x, y) {
		// Only count core hits in phases 2 and 3
		if (self.phase < 2) {
			return false;
		}
		// Check if the hit is within the core
		var coreRadius = coreGraphics.width / 2;
		var dx = x - self.x;
		var dy = y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		return distance <= coreRadius;
	};
	return self;
});
var AirshipTurret = Container.expand(function () {
	var self = Container.call(this);
	var turretGraphics = self.attachAsset('airshipTurret', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 50;
	self.shootCooldown = Math.floor(Math.random() * 60); // Randomize initial cooldown
	self.shootDelay = 120; // 2 seconds between shots
	self.active = true;
	self.offsetX = 0;
	self.offsetY = 0;
	self.parentAirship = null;
	self.update = function () {
		if (!self.active) {
			return;
		}
		// Update position based on parent airship
		if (self.parentAirship) {
			self.x = self.parentAirship.x + self.offsetX;
			self.y = self.parentAirship.y + self.offsetY;
		}
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		} else if (player && self.active) {
			self.shoot();
			self.shootCooldown = self.shootDelay;
		}
	};
	self.shoot = function () {
		if (!player) {
			return;
		}
		// Calculate angle to player
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var angle = Math.atan2(dx, dy);
		var bullet = new EnemyBullet();
		bullet.x = self.x;
		bullet.y = self.y;
		bullet.angle = angle;
		enemyBullets.push(bullet);
		game.addChild(bullet);
		LK.getSound('enemyShoot').play();
	};
	self.takeDamage = function (damage) {
		if (!self.active) {
			return false;
		}
		self.health -= damage;
		// Flash red
		LK.effects.flashObject(self, 0xff0000, 300);
		if (self.health <= 0) {
			self.destroy();
			return true;
		}
		return false;
	};
	self.destroy = function () {
		self.active = false;
		// Create explosion
		var explosion = new Explosion();
		explosion.x = self.x;
		explosion.y = self.y;
		explosion.scale.set(1.5);
		game.addChild(explosion);
		explosions.push(explosion);
		// Hide turret
		turretGraphics.alpha = 0.3;
		LK.getSound('explosion').play();
	};
	return self;
});
var EnemyBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('enemyBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 7;
	self.damage = 10;
	self.angle = 0; // Direction in radians
	self.update = function () {
		// Move based on angle
		self.x += Math.sin(self.angle) * self.speed;
		self.y += Math.cos(self.angle) * self.speed;
		// Cleanup bullets off-screen
		if (self.y > 2732 + 50 || self.y < -50 || self.x < -50 || self.x > 2048 + 50) {
			self.destroy = true;
		}
	};
	return self;
});
var Explosion = Container.expand(function () {
	var self = Container.call(this);
	var explosionGraphics = self.attachAsset('explosion', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lifetime = 30;
	self.update = function () {
		self.lifetime--;
		explosionGraphics.alpha = self.lifetime / 30;
		// Scale up as it fades
		self.scale.set(self.scale.x * 1.05);
		if (self.lifetime <= 0) {
			self.destroy = true;
		}
	};
	return self;
});
var PlayerBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('playerBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 12;
	self.damage = 10;
	self.update = function () {
		self.y -= self.speed;
		// Cleanup bullets off-screen
		if (self.y < -50) {
			self.destroy = true;
		}
	};
	return self;
});
var PlayerFighter = Container.expand(function () {
	var self = Container.call(this);
	// Base fighter graphics
	var fighterGraphics = self.attachAsset('playerFighter', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.speed = 8;
	self.shootCooldown = 0;
	self.shootDelay = 10;
	self.invulnerable = false;
	self.invulnerabilityTimer = 0;
	self.update = function () {
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
		if (self.invulnerable) {
			self.invulnerabilityTimer--;
			fighterGraphics.alpha = Math.floor(self.invulnerabilityTimer / 3) % 2 === 0 ? 1 : 0.5;
			if (self.invulnerabilityTimer <= 0) {
				self.invulnerable = false;
				fighterGraphics.alpha = 1;
			}
		}
	};
	self.shoot = function () {
		if (self.shootCooldown <= 0) {
			var bullet = new PlayerBullet();
			bullet.x = self.x;
			bullet.y = self.y - 50;
			bullets.push(bullet);
			game.addChild(bullet);
			LK.getSound('playerShoot').play();
			self.shootCooldown = self.shootDelay;
			return true;
		}
		return false;
	};
	self.takeDamage = function (damage) {
		if (!self.invulnerable) {
			self.health -= damage;
			self.invulnerable = true;
			self.invulnerabilityTimer = 60; // 1 second invulnerability
			if (self.health <= 0) {
				self.explode();
				return true;
			}
			// Flash red
			LK.effects.flashObject(self, 0xff0000, 500);
			LK.getSound('impact').play();
		}
		return false;
	};
	self.explode = function () {
		for (var i = 0; i < 8; i++) {
			var explosion = new Explosion();
			explosion.x = self.x + (Math.random() * 80 - 40);
			explosion.y = self.y + (Math.random() * 80 - 40);
			explosion.scale.set(0.8 + Math.random() * 1.2);
			game.addChild(explosion);
			explosions.push(explosion);
		}
		LK.getSound('explosion').play();
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000033 // Dark blue space background
});

/**** 
* Game Code
****/ 
// Game state variables
var player = null;
var airship = null;
var bullets = [];
var enemyBullets = [];
var explosions = [];
var allTurrets = [];
var healthBar = null;
var healthBarBg = null;
var scoreText = null;
var gameStarted = false;
var lastShotTime = 0;
var dragNode = null;
// Score and difficulty variables
var score = 0;
var difficulty = 1;
// Initialize game elements
function initGame() {
	// Create sky background (gradient overlay)
	var skyOverlay = LK.getAsset('healthBarBg', {
		width: 2048,
		height: 2732,
		alpha: 0.2,
		anchorX: 0,
		anchorY: 0
	});
	game.addChild(skyOverlay);
	// Create player
	player = new PlayerFighter();
	player.x = 2048 / 2;
	player.y = 2732 - 250;
	game.addChild(player);
	// Create airship
	airship = new Airship();
	airship.x = 2048 / 2;
	airship.y = 300;
	game.addChild(airship);
	airship.initTurrets();
	// Create health bar background
	healthBarBg = LK.getAsset('healthBarBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Create health bar
	healthBar = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	// Position health bars
	healthBarBg.x = 2048 / 2;
	healthBarBg.y = 50;
	healthBar.x = healthBarBg.x - healthBarBg.width / 2 + 5;
	healthBar.y = healthBarBg.y;
	game.addChild(healthBarBg);
	game.addChild(healthBar);
	// Initialize health bar
	updateHealthBar(airship.health, airship.maxHealth);
	// Create score text
	scoreText = new Text2('SCORE: 0', {
		size: 60,
		fill: 0xFFFFFF
	});
	scoreText.anchor.set(1, 0);
	LK.gui.topRight.addChild(scoreText);
	// Start the battle music
	LK.playMusic('battleMusic', {
		fade: {
			start: 0,
			end: 0.5,
			duration: 2000
		}
	});
	gameStarted = true;
}
// Update health bar based on current health
function updateHealthBar(currentHealth, maxHealth) {
	var healthPercent = Math.max(0, currentHealth / maxHealth);
	var targetWidth = healthBarBg.width - 10; // Accounting for padding
	// Update health bar width
	healthBar.width = targetWidth * healthPercent;
	// Change color based on health
	if (healthPercent > 0.6) {
		healthBar.tint = 0x2ecc71; // Green
	} else if (healthPercent > 0.3) {
		healthBar.tint = 0xf39c12; // Orange
	} else {
		healthBar.tint = 0xe74c3c; // Red
	}
}
// Check collision between player bullets and airship
function checkBulletHits() {
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		// Check collision with airship
		if (airship && bullet.intersects(airship)) {
			// Check if it's a core hit
			var isCoreHit = airship.isCoreHit(bullet.x, bullet.y);
			// Apply damage to airship
			var destroyed = airship.takeDamage(bullet.damage, isCoreHit);
			// Add score
			if (isCoreHit) {
				score += 25;
			} else {
				score += 10;
			}
			// Remove bullet
			bullet.destroy = true;
			// Play impact sound
			LK.getSound('impact').play();
			// Create small explosion
			var explosion = new Explosion();
			explosion.x = bullet.x;
			explosion.y = bullet.y;
			explosion.scale.set(0.7);
			game.addChild(explosion);
			explosions.push(explosion);
			// Update score display
			scoreText.setText("SCORE: " + score);
			continue;
		}
		// Check collision with turrets
		for (var j = 0; j < allTurrets.length; j++) {
			var turret = allTurrets[j];
			if (turret.active && bullet.intersects(turret)) {
				var destroyed = turret.takeDamage(bullet.damage);
				// Add score
				if (destroyed) {
					score += 50;
				} else {
					score += 5;
				}
				// Remove bullet
				bullet.destroy = true;
				// Play impact sound
				LK.getSound('impact').play();
				// Create small explosion
				var explosion = new Explosion();
				explosion.x = bullet.x;
				explosion.y = bullet.y;
				explosion.scale.set(0.7);
				game.addChild(explosion);
				explosions.push(explosion);
				// Update score display
				scoreText.setText("SCORE: " + score);
				break;
			}
		}
	}
}
// Check if enemy bullets hit the player
function checkPlayerHit() {
	if (!player) {
		return;
	}
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		var bullet = enemyBullets[i];
		if (bullet.intersects(player)) {
			// Player takes damage
			var destroyed = player.takeDamage(bullet.damage);
			// Remove bullet
			bullet.destroy = true;
			// Create small explosion
			var explosion = new Explosion();
			explosion.x = bullet.x;
			explosion.y = bullet.y;
			explosion.scale.set(0.7);
			game.addChild(explosion);
			explosions.push(explosion);
			if (destroyed) {
				// Game over
				LK.setTimeout(function () {
					LK.showGameOver();
				}, 1000);
			}
		}
	}
}
// Handle player movement
function handleMove(x, y, obj) {
	if (dragNode && player) {
		player.x = x;
		player.y = y;
		// Constrain player to screen bounds
		player.x = Math.max(50, Math.min(2048 - 50, player.x));
		player.y = Math.max(2732 / 2, Math.min(2732 - 50, player.y));
	}
}
// Handle game input
game.down = function (x, y, obj) {
	if (!gameStarted) {
		initGame();
		return;
	}
	if (player) {
		dragNode = player;
		// Auto-fire when touching
		player.shoot();
		lastShotTime = LK.ticks;
	}
	handleMove(x, y, obj);
};
game.up = function (x, y, obj) {
	dragNode = null;
};
game.move = handleMove;
// Update game state each frame
game.update = function () {
	if (!gameStarted) {
		return;
	}
	// Auto-fire while dragging
	if (dragNode && player && LK.ticks - lastShotTime >= player.shootDelay) {
		player.shoot();
		lastShotTime = LK.ticks;
	}
	// Update player
	if (player) {
		player.update();
	}
	// Update airship
	if (airship) {
		airship.update();
	}
	// Update turrets
	for (var i = 0; i < allTurrets.length; i++) {
		allTurrets[i].update();
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		bullets[i].update();
		if (bullets[i].destroy) {
			game.removeChild(bullets[i]);
			bullets.splice(i, 1);
		}
	}
	// Update enemy bullets
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		enemyBullets[i].update();
		if (enemyBullets[i].destroy) {
			game.removeChild(enemyBullets[i]);
			enemyBullets.splice(i, 1);
		}
	}
	// Update explosions
	for (var i = explosions.length - 1; i >= 0; i--) {
		explosions[i].update();
		if (explosions[i].destroy) {
			game.removeChild(explosions[i]);
			explosions.splice(i, 1);
		}
	}
	// Check collisions
	checkBulletHits();
	checkPlayerHit();
};
// Create start message
var startText = new Text2("TAP TO START", {
	size: 100,
	fill: 0xFFFFFF
});
startText.anchor.set(0.5, 0.5);
LK.gui.center.addChild(startText);
// Hide start text when game starts
var checkGameStarted = LK.setInterval(function () {
	if (gameStarted) {
		startText.parent.removeChild(startText);
		LK.clearInterval(checkGameStarted);
	}
}, 100);

===================================================================
--- original.js
+++ change.js
@@ -662,25 +662,25 @@
 	// Update bullets
 	for (var i = bullets.length - 1; i >= 0; i--) {
 		bullets[i].update();
 		if (bullets[i].destroy) {
-			bullets[i].parent.removeChild(bullets[i]);
+			game.removeChild(bullets[i]);
 			bullets.splice(i, 1);
 		}
 	}
 	// Update enemy bullets
 	for (var i = enemyBullets.length - 1; i >= 0; i--) {
 		enemyBullets[i].update();
 		if (enemyBullets[i].destroy) {
-			enemyBullets[i].parent.removeChild(enemyBullets[i]);
+			game.removeChild(enemyBullets[i]);
 			enemyBullets.splice(i, 1);
 		}
 	}
 	// Update explosions
 	for (var i = explosions.length - 1; i >= 0; i--) {
 		explosions[i].update();
 		if (explosions[i].destroy) {
-			explosions[i].parent.removeChild(explosions[i]);
+			game.removeChild(explosions[i]);
 			explosions.splice(i, 1);
 		}
 	}
 	// Check collisions